pi-squire 0.14.0 → 0.16.0

package/src/poll.ts

@@ -26,6 +26,7 @@ function declareGone(pi: ExtensionAPI, results: Results, windows: TmuxWindow[] |
 /** One sweep: claim waiting replies, declare gone every delegation whose window is missing or exited with still no result. */
 async function sweep(pi: ExtensionAPI, results: Results, tmux: TmuxClient, live: () => boolean): Promise<void> {
 	if (results.running().length > 0) {
+		results.syncCloses();
 		const scan: { scanned?: boolean } = {};
 		pi.events.emit(SCAN, scan);
 		// No message:* provider: a waiting reply cannot be ruled out, so nothing is declared gone.

package/src/render.ts

@@ -131,6 +131,7 @@ const ENDINGS: Record<string, { icon: string; color: Color; word: string; wordCo
 	failed: { icon: "✗", color: "error", word: "failed", wordColor: "error" },
 	stopped: { icon: "✗", color: "warning", word: "stopped", wordColor: "warning" },
 	gone: { icon: "✗", color: "warning", word: "closed without a result", wordColor: "warning" },
+	"canceled without a result": { icon: "✗", color: "warning", word: "canceled without a result", wordColor: "warning" },
 };
 
 /** `path` with the home directory shown as `~`. */
@@ -182,7 +183,9 @@ export function renderMessage(
 ): Component | undefined {
 	const details = message.details as MessageDetails | undefined;
 	if (details?.kind !== "result" && details?.kind !== "gone") return undefined;
-	const status = details.kind === "gone" ? "gone" : details.status;
+	const goneStatus =
+		details.kind === "gone" && details.reason === "explicit-close" ? "canceled without a result" : "gone";
+	const status = details.kind === "gone" ? goneStatus : details.status;
 	const background = status === "done" ? "toolSuccessBg" : "toolErrorBg";
 	const box = new Box(outputPad, 1, (text) => theme.bg(background, text));
 	const header = headerLine(details, status, theme);

package/src/result-close.ts

@@ -0,0 +1,37 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { ChildOutcome } from "./child-tasks.ts";
+import { cwdLine, modelLabel, workspaceLine } from "./render.ts";
+import { resumeDetails } from "./result-message.ts";
+import { finishedModel, locateSession, sessionIdOf } from "./result-sessions.ts";
+import { recordedName, type StartedRecorded } from "./result-types.ts";
+import type { MessageDetails } from "./results.ts";
+
+/** A missing/canceled task, never a fabricated result envelope. */
+export function closeOutcome(record: StartedRecorded, ctx: ExtensionContext | undefined): ChildOutcome {
+	const session: string | undefined = locateSession(record, ctx?.sessionManager.getSessionDir());
+	const finished: string | undefined = finishedModel(session);
+	const details: MessageDetails = {
+		kind: "gone",
+		reason: "explicit-close",
+		name: recordedName(record),
+		agent: record.agent,
+		model: record.model,
+		id: record.id,
+		...resumeDetails(record),
+		requestId: record.requestId,
+		windowName: record.windowName,
+		...(finished ? { finishedModel: finished } : {}),
+		...(session ? { sessionPath: session } : {}),
+		cwd: record.cwd,
+		sessionDir: record.sessionDir,
+		workspace: record.workspace,
+	};
+	const content: string = [
+		`[delegate] Delegation ${record.id} (${record.agent}, ${modelLabel(record.model, finished)}), request ${record.requestId}, canceled by explicit close without a result. This is missing work, not successful completion.`,
+		`Working directory: ${cwdLine(record.cwd)}`,
+		...(record.workspace ? [`Workspace: ${workspaceLine(record.workspace)}`] : []),
+		`Delegate session: ${session ?? sessionIdOf(record)}`,
+		"A genuine reply that arrives later is still delivered. Only the direct parent may resume this session as a new delegation.",
+	].join("\n");
+	return { key: `closed:${record.id}`, content, details };
+}

package/src/result-restore.ts

@@ -0,0 +1,95 @@
+// Restore local semantic facts without trusting foreign transcript copies.
+// Any incomplete authoritative read latches a failure until a fresh restore.
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { ChildTasks } from "./child-tasks.ts";
+import { isStarted, type Recorded, type WorkspaceAttempt } from "./result-types.ts";
+import type { Delegation, Result } from "./results.ts";
+import { belongsTo, restoredStarts } from "./tree-view.ts";
+
+export function restoreRecords(ctx: ExtensionContext, tasks: ChildTasks): Recorded[] {
+	const byId: Map<string, Recorded> = new Map();
+	let local: Recorded[] = [];
+	try {
+		local = tasks.restore(ctx.sessionManager.getSessionId());
+	} catch (error) {
+		tasks.blockRestore(error);
+	}
+	try {
+		transcript(ctx, tasks, byId);
+	} catch (error) {
+		tasks.blockRestore(error);
+	}
+	try {
+		for (const record of local) if (accept(record, ctx, tasks, true)) byId.set(record.id, record);
+	} catch (error) {
+		tasks.blockRestore(error);
+	}
+	try {
+		for (const record of restoredStarts(ctx))
+			if (!byId.has(record.id) && accept(record, ctx, tasks, false)) byId.set(record.id, record);
+	} catch (error) {
+		ctx.ui.notify(`delegate: shared launch recovery unavailable: ${String(error)}`, "warning");
+	}
+	try {
+		interrupt([...byId.values()]);
+	} catch (error) {
+		tasks.blockRestore(error);
+	}
+	return [...byId.values()];
+}
+function accept(record: Recorded, ctx: ExtensionContext, tasks: ChildTasks, local: boolean): boolean {
+	try {
+		return belongsTo(record, ctx);
+	} catch (error) {
+		tasks.blockRestore(error);
+		// Keep known own obligations while blocked, never make a foreign copy local.
+		if (!isStarted(record)) return record.parentId === ctx.sessionManager.getSessionId();
+		if (record.identity) return record.identity.parent === ctx.sessionManager.getSessionId();
+		return local;
+	}
+}
+function transcript(ctx: ExtensionContext, tasks: ChildTasks, byId: Map<string, Recorded>): void {
+	for (const entry of ctx.sessionManager.getEntries()) {
+		if (entry.type !== "custom" || entry.customType !== "delegate") continue;
+		const data = entry.data as
+			| Partial<Delegation & { kind: string; result: Result; closed: boolean; gone: boolean }>
+			| undefined;
+		if (!data || typeof data.id !== "string") continue;
+		if (data.kind === "workspace-attempt" || typeof data.requestId === "string") {
+			restoreStart(data as Recorded, ctx, tasks, byId);
+		} else {
+			applyTerminal(byId.get(data.id), data);
+		}
+	}
+}
+function restoreStart(record: Recorded, ctx: ExtensionContext, tasks: ChildTasks, byId: Map<string, Recorded>): void {
+	const existing: Recorded | undefined = byId.get(record.id);
+	if (!isStarted(record) && existing && isStarted(existing)) return;
+	if (accept(record, ctx, tasks, false)) byId.set(record.id, { ...record });
+}
+function applyTerminal(
+	record: Recorded | undefined,
+	data: Partial<Delegation & { result: Result; closed: boolean; gone: boolean }>,
+): void {
+	if (!record || !isStarted(record)) return;
+	if (typeof data.result?.replyId === "string") record.result = data.result;
+	else if (data.closed === true) record.closed = true;
+	else if (data.gone === true) {
+		record.gone = true;
+		if (typeof data.sessionPath === "string") record.sessionPath = data.sessionPath;
+	}
+}
+function interrupt(records: Recorded[]): void {
+	for (const record of records) {
+		if (isStarted(record)) continue;
+		const attempt: WorkspaceAttempt = record;
+		const { phase, resources } = attempt.attempt;
+		if (phase === "planned" || phase === "created")
+			attempt.attempt = {
+				phase: "interrupted",
+				resources,
+				lastPhase: phase,
+				reason: `the parent session ended while the launch was ${phase}; whether anything was created is unknown`,
+			};
+	}
+}

package/src/result-sessions.ts

@@ -77,3 +77,42 @@ export function finishedModel(sessionPath: string | undefined): string | undefin
 	}
 	return undefined;
 }
+
+/** One session-file line, as much of it as the branch walk reads. */
+type BranchEntry = { type?: unknown; id?: unknown; parentId?: unknown; thinkingLevel?: unknown };
+
+/**
+ * The thinking level a delegate's session last changed to on its active
+ * branch: Pi records one `thinking_level_change` when a session starts and
+ * one per later change, the clamp to a new model's levels included. The
+ * branch is the leaf, Pi's last entry, back through each `parentId`.
+ * Undefined when the file cannot be read or holds no change on that branch.
+ */
+export function sessionThinking(sessionPath: string): string | undefined {
+	let lines: string[];
+	try {
+		lines = readFileSync(sessionPath, "utf8").split("\n");
+	} catch {
+		return undefined;
+	}
+	const byId = new Map<string, BranchEntry>();
+	let leaf: BranchEntry | undefined;
+	for (const line of lines) {
+		let entry: BranchEntry;
+		try {
+			entry = JSON.parse(line);
+		} catch {
+			continue;
+		}
+		if (entry?.type === "session" || typeof entry?.id !== "string") continue;
+		byId.set(entry.id, entry);
+		leaf = entry;
+	}
+	const seen = new Set<BranchEntry>();
+	for (let entry = leaf; entry !== undefined && !seen.has(entry); ) {
+		seen.add(entry);
+		if (entry.type === "thinking_level_change" && typeof entry.thinkingLevel === "string") return entry.thinkingLevel;
+		entry = typeof entry.parentId === "string" ? byId.get(entry.parentId) : undefined;
+	}
+	return undefined;
+}

package/src/result-types.ts

@@ -1,4 +1,4 @@
-import type { Delegation } from "./results.ts";
+import type { Delegation, DelegationState, WindowState } from "./results.ts";
 import type { WorktreePlan } from "./worktree.ts";
 
 /** One started delegation as it stands: what was recorded at its start, plus what came after. */
@@ -34,3 +34,31 @@ export type Recorded = StartedRecorded | WorkspaceAttempt;
 export function isStarted(record: Recorded): record is StartedRecorded {
 	return !("kind" in record && record.kind === "workspace-attempt");
 }
+
+/** How much of a delegation id a delegate's session name carries. */
+const SHORT_ID = 8;
+
+/**
+ * A delegate's name, used for both its session and its window: its agent and
+ * the label, or the first 8 characters of its id when there is no label.
+ */
+export function delegateName(agent: string, id: string, label?: string): string {
+	return `${agent}-${label ?? id.slice(0, SHORT_ID)}`;
+}
+
+/** The recorded name, or the pre-label name for records from before labels. */
+export function recordedName(record: Recorded): string {
+	return record.name ?? delegateName(record.agent, record.id);
+}
+
+/** A delegation's state: a recorded close, then a result, then a gone record, then the window. */
+export function deriveState(record: Recorded, window: WindowState): DelegationState {
+	if (!isStarted(record)) return record.attempt.phase;
+	if (record.accountingOnly) return "unknown";
+	if (record.closed === true) return "closed";
+	if (record.result !== undefined) return "done";
+	if (record.gone === true) return "gone";
+	if (window === "open") return "running";
+	if (window === "gone") return "window-closed";
+	return "unknown";
+}

package/src/results-presentation.ts

@@ -0,0 +1,47 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+
+/** Local presentation signals only; neither observers nor count visibility own task state. */
+export class ResultsPresentation {
+	private readonly listeners = new Set<() => void>();
+	private readonly icon: string = Math.random() < 0.5 ? "👨" : "👩";
+	private visible = true;
+	private shown = false;
+	private ctx: ExtensionContext | undefined;
+	private count = 0;
+
+	subscribe = (listener: () => void): (() => void) => {
+		this.listeners.add(listener);
+		return () => {
+			this.listeners.delete(listener);
+		};
+	};
+
+	setCountVisible = (visible: boolean): void => {
+		this.visible = visible;
+		this.footer();
+	};
+
+	update(ctx: ExtensionContext | undefined, count: number): void {
+		this.ctx = ctx;
+		this.count = count;
+		this.footer();
+		for (const listener of this.listeners) {
+			try {
+				listener();
+			} catch {
+				/* An optional view cannot interrupt task/result processing. */
+			}
+		}
+	}
+
+	private footer(): void {
+		if (this.ctx?.hasUI !== true) return;
+		const visible: boolean = this.visible && this.count > 0;
+		if (!visible && !this.shown) return;
+		this.shown = visible;
+		this.ctx.ui.setStatus(
+			"delegate",
+			visible ? `${this.icon} ${this.count} delegate${this.count === 1 ? "" : "s"} running` : undefined,
+		);
+	}
+}