@giladbarnea/pi-user-agents 0.0.3 → 0.0.5

package/widget.ts

@@ -15,9 +15,11 @@ import {
 	type ViewableAgent,
 } from "./agent-viewer.js";
 import { renderAgentContextMeter } from "./context-meter.js";
+import { selectRebaseMessages } from "./rebase.js";
 import type {
 	AgentResultMessage,
 	CompletedAgent,
+	RebaseDelivery,
 	RunningAgent,
 	Theme,
 	UIContext,
@@ -25,6 +27,7 @@ import type {
 import {
 	contextLabel,
 	formatMs,
+	TimedConfirmation,
 	formatToolUses,
 	formatTurns,
 	logSteering,
@@ -49,12 +52,15 @@ export class UserAgentWidget {
 	private active = false;
 	private selectedIndex = 0;
 	private viewerOpen = false;
-	private disposeConfirmationTarget: ViewableAgent | undefined;
+	/** One confirmation slot for detaching the selected agent. */
+	private readonly detachConfirmation = new TimedConfirmation<ViewableAgent>(() => this.update());
 	private readonly completedAgents: CompletedAgent[] = [];
 
 	constructor(
 		private readonly runningAgents: Set<RunningAgent>,
-		private readonly sendJoinedResult: (message: AgentResultMessage) => void,
+		private readonly sendSquashedResult: (message: AgentResultMessage) => void,
+		private readonly announceDetached: (sessionId: string) => void,
+		private readonly rebaseDelivery: RebaseDelivery,
 	) {}
 
 	setUI(ui: UIContext): void {
@@ -63,22 +69,24 @@ export class UserAgentWidget {
 		this.ui = ui;
 		this.widgetRegistered = false;
 		this.tui = undefined;
-		this.disposeConfirmationTarget = undefined;
+		this.detachConfirmation.cancel();
 		this.inputUnsub = ui.onTerminalInput((data) => this.handleKey(data));
 	}
 
 	addCompleted(
 		agent: RunningAgent,
 		resultMessage: AgentResultMessage,
-		options: { joinable: boolean },
+		options: { squashable: boolean },
 	): void {
 		this.completedAgents.push({
 			id: agent.id,
+			sessionId: agent.sessionId,
 			command: agent.command,
 			modelLabel: agent.modelLabel,
 			task: agent.task,
+			dispatchBaseFingerprint: agent.dispatchBaseFingerprint,
 			mainContextState: agent.mainContextState,
-			pendingJoinMessage: options.joinable ? resultMessage : undefined,
+			pendingSquashMessage: options.squashable ? resultMessage : undefined,
 			ok: resultMessage.details.ok,
 			responseText: agent.responseText,
 			messages: structuredClone(transcriptMessages(agent)),
@@ -140,7 +148,7 @@ export class UserAgentWidget {
 		this.widgetRegistered = false;
 		this.tui = undefined;
 		this.active = false;
-		this.disposeConfirmationTarget = undefined;
+		this.detachConfirmation.cancel();
 	}
 
 	private clear(): void {
@@ -155,7 +163,7 @@ export class UserAgentWidget {
 		}
 		this.active = false;
 		this.selectedIndex = 0;
-		this.disposeConfirmationTarget = undefined;
+		this.detachConfirmation.cancel();
 	}
 
 	private runningAgentsForWidget(): RunningAgent[] {
@@ -199,13 +207,13 @@ export class UserAgentWidget {
 		}
 
 		if (matchesKey(data, "down")) {
-			this.disposeConfirmationTarget = undefined;
+			this.detachConfirmation.cancel();
 			this.selectedIndex = Math.min(entries.length - 1, this.selectedIndex + 1);
 			this.update();
 			return { consume: true };
 		}
 		if (matchesKey(data, "up")) {
-			this.disposeConfirmationTarget = undefined;
+			this.detachConfirmation.cancel();
 			if (this.selectedIndex === 0) {
 				this.deactivate();
 				return { consume: true };
@@ -225,17 +233,17 @@ export class UserAgentWidget {
 			selected?.kind === "running" &&
 			isLiveAgent(selected.agent)
 		) {
-			this.disposeConfirmationTarget = undefined;
+			this.detachConfirmation.cancel();
 			this.interruptRunning(selected.agent);
 			return { consume: true };
 		}
 		if (matchesKey(data, "enter")) {
-			this.disposeConfirmationTarget = undefined;
+			this.detachConfirmation.cancel();
 			if (selected) this.openSelected(selected.agent);
 			return { consume: true };
 		}
-		if (matchesKey(data, "x") && selected) {
-			if (!this.confirmDispose(selected.agent)) return { consume: true };
+		if (matchesKey(data, "d") && selected) {
+			if (!this.confirmDetach(selected.agent)) return { consume: true };
 			if (selected.kind === "running") this.closeRunning(selected.agent);
 			else this.dismissCompleted(selected.agent);
 			return { consume: true };
@@ -245,20 +253,16 @@ export class UserAgentWidget {
 		return undefined;
 	}
 
-	private confirmDispose(target: ViewableAgent): boolean {
-		if (this.disposeConfirmationTarget === target) {
-			this.disposeConfirmationTarget = undefined;
-			return true;
-		}
-		this.disposeConfirmationTarget = target;
-		this.update();
-		return false;
+	private confirmDetach(target: ViewableAgent): boolean {
+		const confirmed = this.detachConfirmation.press(target);
+		if (!confirmed) this.update();
+		return confirmed;
 	}
 
 	private deactivate(): void {
 		this.active = false;
 		this.selectedIndex = 0;
-		this.disposeConfirmationTarget = undefined;
+		this.detachConfirmation.cancel();
 		this.update();
 	}
 
@@ -284,13 +288,17 @@ export class UserAgentWidget {
 						agent,
 						theme,
 						done,
-						() => this.canJoinMainContext(agent.id),
-						() => this.joinMainContext(agent.id),
+						() => this.canSquashMainContext(agent.id),
+						() => this.squashMainContext(agent.id),
+						() => this.canRebaseMainContext(agent.id),
+						() => this.rebaseMainContext(agent.id),
+						() => this.rebaseBlockReason(agent.id),
+						() => this.rebaseDetachCount(agent.id),
 						() => {
 							if (isRunningAgent(agent)) this.interruptRunning(agent);
 						},
 					),
-				{ overlay: true, overlayOptions: { anchor: "center", width: "90%", maxHeight: "70%" } },
+				{ overlay: true, overlayOptions: { anchor: "center", width: "90%", maxHeight: "85%" } },
 			)
 			.then(
 				(action) => this.onViewerClosed(agent, action),
@@ -298,10 +306,12 @@ export class UserAgentWidget {
 			);
 	}
 
+	/** Detaching ends the live session and leaves its session file on disk, untouched. */
 	private closeRunning(agent: RunningAgent): void {
 		agent.aborted = true;
 		void agent.session?.abort();
 		agent.retire?.();
+		this.announceDetached(agent.sessionId);
 		this.update();
 	}
 
@@ -315,65 +325,118 @@ export class UserAgentWidget {
 		return [...this.runningAgents].find((agent) => agent.id === agentId && agent.status === "idle");
 	}
 
-	private canJoinMainContext(agentId: string): boolean {
-		if (this.idleAgent(agentId)?.pendingJoinMessage) return true;
-		return this.completedAgents.some(
-			(agent) => agent.id === agentId && agent.pendingJoinMessage !== undefined,
-		);
+	private canSquashMainContext(agentId: string): boolean {
+		return this.deliverableAgent(agentId) !== undefined;
 	}
 
-	confirmMainContextJoin(agentId: string): boolean {
+	confirmMainContextSquash(agentId: string): boolean {
 		const agents = [
 			...[...this.runningAgents].filter((candidate) => candidate.id === agentId),
 			...this.completedAgents.filter((candidate) => candidate.id === agentId),
-		].filter((candidate) => candidate.mainContextState === "will-join");
+		].filter((candidate) => candidate.mainContextState === "will-squash");
 		if (agents.length === 0) return false;
-		for (const agent of agents) agent.mainContextState = "joined";
+		for (const agent of agents) agent.mainContextState = "squashed";
 		this.update();
 		return true;
 	}
 
-	private joinMainContext(agentId: string): void {
+	private squashMainContext(agentId: string): void {
 		const idleAgent = this.idleAgent(agentId);
 		if (idleAgent) {
-			this.joinIdleAgent(idleAgent);
+			this.squashIdleAgent(idleAgent);
 			return;
 		}
 		const completedAgent = this.completedAgents.find((agent) => agent.id === agentId);
-		const message = completedAgent?.pendingJoinMessage;
+		const message = completedAgent?.pendingSquashMessage;
 		if (!completedAgent || !message) return;
 
-		completedAgent.pendingJoinMessage = undefined;
-		completedAgent.mainContextState = "will-join";
-		message.details.mainContextState = "will-join";
-		this.sendJoinedResult(message);
-		logSteering(agentId, "joined-main-context", { display: message.display });
+		completedAgent.pendingSquashMessage = undefined;
+		completedAgent.mainContextState = "will-squash";
+		message.details.mainContextState = "will-squash";
+		this.sendSquashedResult(message);
+		logSteering(agentId, "squashed-main-context", { display: message.display });
+		this.update();
+	}
+
+	/** An agent whose latest turn result is still deliverable: idle live, or completed and squashable. */
+	private deliverableAgent(agentId: string): RunningAgent | CompletedAgent | undefined {
+		const idleAgent = this.idleAgent(agentId);
+		if (idleAgent?.pendingSquashMessage) return idleAgent;
+		return this.completedAgents.find(
+			(agent) => agent.id === agentId && agent.pendingSquashMessage !== undefined,
+		);
+	}
+
+	private canRebaseMainContext(agentId: string): boolean {
+		return this.deliverableAgent(agentId) !== undefined && this.rebaseBlockReason(agentId) === undefined;
+	}
+
+	/** How many other agent sessions the rebase cascade would detach. */
+	private rebaseDetachCount(agentId: string): number {
+		return (
+			[...this.runningAgents].filter((agent) => agent.id !== agentId).length +
+			this.completedAgents.filter((agent) => agent.id !== agentId).length
+		);
+	}
+
+	/** Why a deliverable result cannot rebase right now; undefined when it can, or when nothing is deliverable. */
+	private rebaseBlockReason(agentId: string): string | undefined {
+		const agent = this.deliverableAgent(agentId);
+		if (!agent) return undefined;
+		// The session switch tears the extension runtime down, which would abort a mid-turn sibling.
+		if ([...this.runningAgents].some(isLiveAgent)) return "another agent is mid-turn";
+		if (!this.rebaseDelivery.canDeliver(agent))
+			return "the main session has drifted since dispatch";
+		return undefined;
+	}
+
+	/** Fast-forward the raw child conversation onto the main session, then retire the agent. */
+	private rebaseMainContext(agentId: string): void {
+		if (!this.canRebaseMainContext(agentId)) return;
+		const agent = this.deliverableAgent(agentId);
+		if (!agent) return;
+		// The reload will not preserve live rows; give every sibling its resumable-session breadcrumb.
+		for (const other of [...this.runningAgents]) if (other !== agent) this.closeRunning(other);
+		for (const other of [...this.completedAgents]) if (other !== agent) this.removeCompleted(other);
+		const message = agent.pendingSquashMessage;
+		this.rebaseDelivery.deliver(
+			agent,
+			selectRebaseMessages(agent.task, structuredClone(transcriptMessages(agent))),
+		);
+		agent.pendingSquashMessage = undefined;
+		agent.mainContextState = "rebased";
+		if (isRunningAgent(agent)) {
+			agent.status = "posted";
+			if (message) this.addCompleted(agent, message, { squashable: false });
+			agent.retire?.();
+		}
+		logSteering(agentId, "rebased-main-context");
 		this.update();
 	}
 
-	/** Joining is one of the two terminal actions on a live idle agent: deliver the result, snapshot it, retire the session. */
-	private joinIdleAgent(agent: RunningAgent): void {
-		const message = agent.pendingJoinMessage;
+	/** Squashing is one of the two terminal actions on a live idle agent: deliver the result, snapshot it, retire the session. */
+	private squashIdleAgent(agent: RunningAgent): void {
+		const message = agent.pendingSquashMessage;
 		if (!message) return;
-		agent.pendingJoinMessage = undefined;
-		agent.mainContextState = "will-join";
-		message.details.mainContextState = "will-join";
+		agent.pendingSquashMessage = undefined;
+		agent.mainContextState = "will-squash";
+		message.details.mainContextState = "will-squash";
 		agent.status = "posted";
-		this.addCompleted(agent, message, { joinable: false });
-		this.sendJoinedResult(message);
+		this.addCompleted(agent, message, { squashable: false });
+		this.sendSquashedResult(message);
 		agent.retire?.();
-		logSteering(agent.id, "joined-main-context", { display: message.display, live: true });
+		logSteering(agent.id, "squashed-main-context", { display: message.display, live: true });
 		this.update();
 	}
 
 	private onViewerClosed(agent: ViewableAgent, action: AgentViewerAction): void {
 		this.viewerOpen = false;
-		if (action === "dispose" && isRunningAgent(agent) && this.runningAgents.has(agent)) {
+		if (action === "detach" && isRunningAgent(agent) && this.runningAgents.has(agent)) {
 			this.closeRunning(agent);
 			return;
 		}
 		const completedAgent = this.completedAgents.find((candidate) => candidate.id === agent.id);
-		if (action === "dispose" && completedAgent) this.removeCompleted(completedAgent);
+		if (action === "detach" && completedAgent) this.removeCompleted(completedAgent);
 		else this.update();
 	}
 
@@ -384,6 +447,7 @@ export class UserAgentWidget {
 	private removeCompleted(agent: CompletedAgent): void {
 		const index = this.completedAgents.indexOf(agent);
 		if (index >= 0) this.completedAgents.splice(index, 1);
+		this.announceDetached(agent.sessionId);
 		const total = this.entries().length;
 		if (total === 0) {
 			this.deactivate();
@@ -413,18 +477,19 @@ export class UserAgentWidget {
 			lines.push(truncateToWidth(`  ${theme.fg("dim", "←/↓ select agent")}`, width));
 		} else {
 			const selected = entries[this.selectedIndex];
-			const confirmingDispose = this.disposeConfirmationTarget === selected?.agent;
+			const confirmingDetach =
+				selected !== undefined && this.detachConfirmation.isArmedOn(selected.agent);
 			const segments = [theme.fg("accent", "↑↓ select"), theme.fg("accent", "Enter view")];
 			if (
-				!confirmingDispose &&
+				!confirmingDetach &&
 				selected?.kind === "running" &&
 				isLiveAgent(selected.agent)
 			)
 				segments.push(theme.fg("accent", "Ctrl+x interrupt"));
 			segments.push(
 				theme.fg(
-					confirmingDispose ? "error" : "accent",
-					confirmingDispose ? "x again to confirm" : "x dispose",
+					confirmingDetach ? "error" : "accent",
+					confirmingDetach ? "d again to confirm" : "d detach",
 				),
 				theme.fg("accent", "Esc back"),
 			);