@giladbarnea/pi-user-agents 0.0.6 → 0.0.8

package/INTERNALS.md

@@ -16,9 +16,9 @@ How a finished run reaches (or hides from) the main agent rests on two Pi SDK ch
 
 - **`pi.appendEntry(customType, data)` + `pi.registerEntryRenderer`** — the only channel that renders in the transcript while staying out of LLM context *forever*. Entries are persisted in the session file and re-rendered on reload. The entry's `data` is optional in the type — renderers must guard it.
 
-This extension maps the two extremes onto the `-s` flag: the default posts the result card via `appendEntry` (main agent structurally oblivious), and `-s` posts a visible custom message with `{ triggerTurn: true }` (steered mid-turn or answered immediately). Both channels share one card renderer in `transcript.ts`.
+Default completion writes no entry or message to the parent session. The widget and agent overlay show the response. `-s` sends a hidden custom message with `{ triggerTurn: true }`, steered mid-turn or answered immediately.
 
-Immediate `-s` delivery and late `s` squash delivery share one canonical message builder. Its `display` option prevents a second visible result card. Both paths use the same selected conversation and `{ triggerTurn: true }` delivery. For a run launched without `-s`, the context message stays hidden at squash time because the TUI-only result card is already visible.
+Immediate `-s` delivery and late `s` squash delivery share one canonical message builder and use `display: false`. Both paths preserve the selected conversation and `{ triggerTurn: true }` delivery. `transcript.ts` renders old completion entries and messages as zero lines, preventing Pi's fallback renderer from showing them. Command errors and detach, attach, and rebase breadcrumbs remain visible.
 
 ## Squashed message format
 
@@ -46,7 +46,7 @@ A child compaction passes through deliberately and lands as a real `compaction`
 
 Two mechanics make that exact. First, a live compaction emits no message event — only `compaction_end` — so the child subscription captures it there as a synthetic `compactionSummary` message, or the append-only conversation would never contain it. Second, the kept-tail boundary (`firstKeptEntryId`) is a child-session entry id that means nothing in the main session's file; but at `compaction_end` the child's live context is exactly `[summary, kept tail]`, so the capture records `keptTailCount`, and the rebase replay counts back that many context messages to pass the main-session id of the message that starts the tail. The tail may reach past the replayed messages into main's pre-existing context — a child that inherits a nearly full context compacts early — so the delivery prepends main's own per-message entry ids to the count.
 
-The fast-forward precondition is fingerprint equality: at dispatch the agent stores `JSON.stringify` of the inherited context messages (`[]` for `-i`), and `r` is offered only while the main session's current `buildSessionContext().messages` fingerprint still matches. The live fingerprint is cached per session manager and recomputed only when the branch leaf moves, so TUI-only entries (result cards, detach lines) move the leaf, trigger one recompute, and correctly do not block the rebase. One rule covers isolated agents too: their base is empty, so they rebase only onto a still-empty session.
+The fast-forward precondition is fingerprint equality: at dispatch the agent stores `JSON.stringify` of the inherited context messages (`[]` for `-i`), and `r` is offered only while the main session's current `buildSessionContext().messages` fingerprint still matches. The live fingerprint is cached per session manager and recomputed only when the branch leaf moves, so TUI-only entries (detach and attach lines) move the leaf, trigger one recompute, and correctly do not block the rebase. One rule covers isolated agents too: their base is empty, so they rebase only onto a still-empty session.
 
 Because the session switch tears the extension down, live widget rows cannot survive it: `r` is withheld while any agent is mid-turn, and the remaining parked and completed agents are detached first through the ordinary detach paths, so every one of them leaves its `Detached session …` breadcrumb before the switch. The switch re-opens the same file, so the session id does not change.
 

package/README.md

@@ -69,7 +69,7 @@ Every agent gets a row in a widget under the editor: status, task, model, turn c
 
 <br>
 
-Press `←` or `↓` from the editor to focus the widget, pick an agent, press `Enter`, and its overlay opens: the full conversation, streaming live, following the tail as it grows. Tool calls render as proper views — `read`, `edit`, `write`, `grep`, `find`, `ls`, and `bash` each get a dedicated format, everything else a readable generic one.
+Press `←` or `↓` from the editor to focus the widget. The selected row shows a short session ID and offers the same agent actions as the overlay. Press `Enter` to open the full conversation, streaming live and following the tail as it grows. Tool calls render as proper views — `read`, `edit`, `write`, `grep`, `find`, `ls`, and `bash` each get a dedicated format, everything else a readable generic one.
 
 <a href="screenshots/overlay.png">
   <img src="screenshots/overlay.png" width="100%" alt="The agent overlay: a rendered bash call, its output, a todo update, and the final response, over the dimmed main conversation">
@@ -81,7 +81,7 @@ Press `←` or `↓` from the editor to focus the widget, pick an agent, press `
 
 A background agent is not fire-and-forget — it's a session you can talk to.
 
-Press `Enter` in the overlay to open the steer composer. Mid-turn, your message queues in after the current tool batch, before the next model call — exactly like steering the main agent. After the turn completes, the same composer starts **another turn** on the same live session. Follow up as many times as you need; every completed turn posts its own result card.
+Press `Enter` in the overlay to open the steer composer. Mid-turn, your message queues in after the current tool batch, before the next model call — exactly like steering the main agent. After the turn completes, the same composer starts **another turn** on the same live session. Follow up as many times as you need. Read each response in the agent overlay.
 
 `Ctrl+x` interrupts only the current turn — the agent goes idle and stays available for steering, squashing, or detaching. In fact, nothing ends an agent except you: pressing `d` twice, squashing or rebasing it, or ending the Pi session.
 
@@ -101,14 +101,14 @@ Or take it back as a background agent instead: `/agent-attach 0199c4f2` puts the
 
 This is what makes user agents different from subagents: **by default, the main agent never learns any of this happened.**
 
-Each completed turn posts a result card into your transcript — metadata, a collapsed preview, expandable to the full Markdown response. The card is TUI-only: you read it, expand it, copy it, and the main agent's context is untouched. Ask an agent ten questions and your main agent's token budget doesn't move.
+Completed responses stay in the agent overlay, accessible through the widget below the editor. Completion adds no transcript card. Ask an agent ten questions and your main agent's token budget does not move.
 
 When a result does belong in the main conversation, squash it in:
 
 - Dispatch with `-s`/`--squash` and the result is delivered automatically on completion.
 - Or press `s` in the overlay of any completed agent, whenever you decide it earned its place.
 
-A squash delivers a compact record, not a transcript dump: every message you sent the agent and the final answer to each — no thinking, no tool traffic. The record is rebuilt from the agent's full history at squash time, so early turns survive even after the agent compacts its own context. If the main agent is mid-turn, the record is steered in; if idle, it triggers a turn. A squashed agent retires; its overlay stays readable.
+A squash delivers a compact record, not a transcript dump: every message you sent the agent and the final answer to each — no thinking, no tool traffic. The record is rebuilt from the agent's full history at squash time, so early turns survive even after the agent compacts its own context. If the main agent is mid-turn, the record is steered in; if idle, it triggers a turn. Squash adds no transcript card. A squashed agent retires; its overlay stays readable.
 
 ### 6. Or rebase — rewrite history
 
@@ -148,7 +148,7 @@ And what you do type by hand is checked live, as you type. Valid options and val
 
 Every dispatch writes a real session file, exactly like the one you're sitting in, so dispatched agents show up in `/resume` and `pi -r` alongside your own sessions.
 
-Result cards persist across session reloads; the widget doesn't. After a reload you keep every card, and every agent's session is still on disk — but the steerable rows are gone. Reach them with `/resume`.
+The widget does not survive a session reload. Each agent's session remains on disk, accessible through `/resume` or `/agent-attach`. Completion cards from older versions stay hidden.
 
 ### 🌡️ A context meter in one cell
 
@@ -173,15 +173,16 @@ Everything goes through one command: `/agent [options] <task>`. Its one companio
 | Widget / overlay | `d` `d` | Detach the agent, keeping its session (twice to confirm) |
 | Widget / overlay | `Esc` | Back |
 | Overlay | `Enter` | Steer mid-turn, or start another turn when idle |
-| Overlay | `s` | Squash the conversation into the main context |
-| Overlay | `r` | Rebase the raw conversation into the main context (fast-forward only) |
-| Overlay | `c` | Copy the latest response |
+| Widget / overlay | `s` | Squash the conversation into the main context |
+| Widget / overlay | `r` | Rebase the raw conversation into the main context (fast-forward only) |
+| Widget / overlay | `c` | Copy the latest response |
+| Widget / overlay | `i` | Copy the agent's full session ID |
 | Overlay | scroll · `End` | Pause tail-following · resume it |
 
 ## Good to know
 
 - Some accepted `pi` options have no effect on a background run (the session, approval, offline, and API-key families). They parse; they just don't do anything yet.
-- `c` copies via `pbcopy`, so it's macOS-only for now.
+- `c` and `i` copy via `pbcopy`, so they are macOS-only for now.
 - The overlay caps very large tool outputs and omits thinking entries.
 
 ## Roadmap

package/agent-viewer.ts

@@ -102,7 +102,14 @@ function describeAssistantPart(part: AssistantContentPart): ActivityDescription
 
 export function renderActivity(description: ActivityDescription, width: number, theme: Theme): string {
 	if (width <= 0) return "";
-	const normalized = description.text.replace(/\s+/g, " ").trim();
+	const limit = Math.min(4096, Math.max(128, width * 4));
+	const text = description.text;
+	const bounded = text.length <= limit
+		? text
+		: description.truncation === "tail"
+			? `${text.slice(0, limit - 1)}…`
+			: `${text.slice(0, Math.ceil((limit - 1) / 2))}…${text.slice(-Math.floor((limit - 1) / 2))}`;
+	const normalized = bounded.replace(/\s+/g, " ").trim();
 	const dim = (text: string) => theme.fg("dim", text);
 	const markdown = new Markdown(normalized, 0, 0, dimMarkdownThemeFromTheme(theme), { color: dim });
 	const rendered = markdown
@@ -144,13 +151,17 @@ function truncateMiddle(
 const VIEWER_CHROME_LINES = 6;
 const VIEWER_MIN_VIEWPORT = 3;
 const VIEWER_HEIGHT_PCT = 85;
+const COPY_FEEDBACK_MS = 1500;
+
+type CopyTarget = "response" | "session-id";
 
 /** Focus-capturing overlay that shows an agent's live or finished response. */
 export class AgentViewer implements Component {
 	private scrollOffset = 0;
 	private autoScroll = true;
 	private lastWidth = 0;
-	private justCopied = false;
+	private copied: CopyTarget | undefined;
+	private copiedTimer: ReturnType<typeof setTimeout> | undefined;
 	private rebaseWarning: string | undefined;
 	private rebaseWarningTimer: ReturnType<typeof setTimeout> | undefined;
 	/** One confirmation slot for both destructive overlay actions. */
@@ -158,7 +169,7 @@ export class AgentViewer implements Component {
 		this.tui.requestRender(),
 	);
 	private composer: Input | undefined;
-	/** Rich tool rendering is far too costly to repeat on every 100 ms widget tick. */
+	/** Rich tool rendering is far too costly to repeat on every widget tick. */
 	private renderedContent: { key: string; lines: string[] } | undefined;
 
 	constructor(
@@ -205,6 +216,10 @@ export class AgentViewer implements Component {
 			this.copyResponse();
 			return;
 		}
+		if (matchesKey(data, "i")) {
+			this.copyToClipboard(this.agent.sessionId, "session-id");
+			return;
+		}
 		if (matchesKey(data, "s") && this.canSquashMainContext()) {
 			this.squashMainContext();
 			this.tui.requestRender();
@@ -344,7 +359,11 @@ export class AgentViewer implements Component {
 					th.fg("dim", `${content.length} lines`),
 					th.fg("dim", scrollPct),
 					this.canSteer() ? th.fg("dim", "Enter steer") : "",
-					this.justCopied ? th.fg("success", "✓ copied") : th.fg("dim", "c copy"),
+					this.copied === "response"
+						? th.fg("success", "✓ copied")
+						: this.copied === "session-id"
+							? th.fg("success", "✓ copied ID")
+							: th.fg("dim", "c copy · i ID"),
 					th.fg("dim", "↑↓ scroll"),
 					th.fg("dim", "PgUp/PgDn"),
 					this.canSquashMainContext() ? th.fg("dim", "s squash") : "",
@@ -364,7 +383,9 @@ export class AgentViewer implements Component {
 		return lines;
 	}
 
-	invalidate(): void {}
+	invalidate(): void {
+		this.renderedContent = undefined;
+	}
 
 	dispose(): void {}
 
@@ -392,14 +413,20 @@ export class AgentViewer implements Component {
 			isRunningAgent(this.agent) || this.agent.ok
 				? this.agent.responseText
 				: (this.agent.error ?? "");
+		this.copyToClipboard(text, "response");
+	}
+
+	private copyToClipboard(text: string, target: CopyTarget): void {
 		const child = childProcess.execFile("pbcopy", (error) => {
 			if (error) return;
-			this.justCopied = true;
+			this.copied = target;
+			if (this.copiedTimer) clearTimeout(this.copiedTimer);
 			this.tui.requestRender();
-			setTimeout(() => {
-				this.justCopied = false;
+			this.copiedTimer = setTimeout(() => {
+				this.copied = undefined;
+				this.copiedTimer = undefined;
 				this.tui.requestRender();
-			}, 1500);
+			}, COPY_FEEDBACK_MS);
 		});
 		child.stdin?.end(text);
 	}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@giladbarnea/pi-user-agents",
-  "version": "0.0.6",
+  "version": "0.0.8",
   "description": "Run, view, and control background Pi agents.",
   "keywords": [
     "pi-package",

package/runner.ts

@@ -192,14 +192,9 @@ function postUserAgentResult(
 	notifyMainAgent: boolean,
 	message: AgentResultMessage,
 ): boolean {
-	if (isShuttingDown()) return false;
-	if (notifyMainAgent) {
-		// Steers into a streaming turn, or triggers an immediate response when idle.
-		pi.sendMessage(message, { triggerTurn: true });
-	} else {
-		// TUI-only session entry: renders in the transcript but never enters the main agent's context.
-		pi.appendEntry(message.customType, { content: message.content, details: message.details });
-	}
+	if (isShuttingDown() || !notifyMainAgent) return false;
+	// Steers into a streaming turn, or triggers an immediate response when idle.
+	pi.sendMessage(message, { triggerTurn: true });
 	return true;
 }
 
@@ -490,7 +485,7 @@ async function runAgentLifecycle(
 	}
 }
 
-/** Settle a failed lifecycle: record the error and post the error card, unless the user aborted. */
+/** Record a failed lifecycle in the widget and deliver it only when squash was requested. */
 export function reportAgentFailure(
 	pi: ExtensionAPI,
 	isShuttingDown: () => boolean,
@@ -514,7 +509,7 @@ export function reportAgentFailure(
 	const resultMessage = buildAgentResultMessage(
 		runningAgent,
 		{ ok: false, error: message },
-		{ display: runningAgent.notifyMainAgent },
+		{ display: false },
 	);
 	widget.addCompleted(runningAgent, resultMessage, { squashable: !runningAgent.notifyMainAgent });
 	if (postUserAgentResult(pi, isShuttingDown, runningAgent.notifyMainAgent, resultMessage))
@@ -556,7 +551,6 @@ export async function runChildTurns(
 				{ ok: true, response },
 				{ display: false },
 			);
-			postUserAgentResult(pi, isShuttingDown, false, resultMessage);
 			runningAgent.pendingSquashMessage = runningAgent.notifyMainAgent
 				? undefined
 				: resultMessage;
@@ -581,7 +575,7 @@ export async function runChildTurns(
 		const resultMessage = buildAgentResultMessage(
 			runningAgent,
 			{ ok: true, response },
-			{ display: runningAgent.notifyMainAgent },
+			{ display: false },
 		);
 		if (runningAgent.notifyMainAgent) {
 			if (isShuttingDown()) {
@@ -594,7 +588,6 @@ export async function runChildTurns(
 			runningAgent.status = posted ? "posted" : runningAgent.status;
 			return;
 		}
-		postUserAgentResult(pi, isShuttingDown, false, resultMessage);
 		runningAgent.pendingSquashMessage = resultMessage;
 		if (isShuttingDown()) return;
 		runningAgent.status = "idle";

package/shared.ts

@@ -98,8 +98,6 @@ export type AgentCommandDetails = {
 	toolUses?: number;
 	turnCount?: number;
 	responseText?: string;
-	/** Retained for completed entries written before responseText was persisted. */
-	responsePreview?: string;
 	error?: string;
 };
 
@@ -294,14 +292,6 @@ export function truncatePlain(text: string, length: number): string {
 	return `${line.slice(0, Math.max(0, length - 1))}…`;
 }
 
-export function extractTag(
-	content: string,
-	tag: "task" | "response" | "error" | "duration_ms",
-): string | undefined {
-	const match = content.match(new RegExp(`<${tag}>\\n?([\\s\\S]*?)\\n?</${tag}>`));
-	return match?.[1]?.trim();
-}
-
 export function escapeAttribute(value: string): string {
 	return value
 		.replace(/&/g, "&amp;")

package/transcript.ts

@@ -1,5 +1,4 @@
-import { getMarkdownTheme } from "@earendil-works/pi-coding-agent";
-import { type Component, Container, Markdown, Text } from "@earendil-works/pi-tui";
+import { type Component, Text } from "@earendil-works/pi-tui";
 import type {
 	AgentCommandDetails,
 	AgentCommandName,
@@ -12,21 +11,15 @@ import type {
 	ExtensionCommandContext,
 	RebasedEntryData,
 	RunningAgent,
-	Theme,
 } from "./shared.js";
 import {
 	ATTACHED_ENTRY_TYPE,
 	contextLabel,
 	DETACHED_ENTRY_TYPE,
 	escapeAttribute,
-	extractTag,
-	formatMs,
-	formatToolUses,
-	formatTurns,
 	mainContextLabel,
 	MESSAGE_TYPE,
 	REBASED_ENTRY_TYPE,
-	truncatePlain,
 } from "./shared.js";
 
 export function reportCommandError(
@@ -195,28 +188,14 @@ export function formatStartNotification(agent: RunningAgent): string {
 }
 
 export function registerUserAgentRenderer(pi: ExtensionAPI): void {
-	pi.registerMessageRenderer<AgentCommandDetails>(
-		MESSAGE_TYPE,
-		(message, { expanded }, theme) =>
-			liveAgentCard(
-				() => customMessageContentText(message.content),
-				() => message.details,
-				expanded,
-				theme,
-			),
-	);
-	pi.registerEntryRenderer<AgentEntryData>(
-		MESSAGE_TYPE,
-		(entry, { expanded }, theme) =>
-			entry.data
-				? liveAgentCard(
-						() => entry.data!.content,
-						() => entry.data!.details,
-						expanded,
-						theme,
-					)
-				: undefined,
-	);
+	const hiddenResult: Component = { render: () => [], invalidate: () => undefined };
+	pi.registerMessageRenderer<AgentCommandDetails>(MESSAGE_TYPE, (message, _state, theme) => {
+		const details = message.details;
+		if (!details || details.agentId || details.inheritedContext !== undefined || details.ok)
+			return hiddenResult;
+		return new Text(theme.fg("error", `/${details.command}: ${details.error}`), 1, 0);
+	});
+	pi.registerEntryRenderer<AgentEntryData>(MESSAGE_TYPE, () => hiddenResult);
 	// Pi's chat container does not pad renderer components; its own chat lines self-pad with paddingX 1.
 	pi.registerEntryRenderer<DetachedEntryData>(DETACHED_ENTRY_TYPE, (entry, _state, theme) =>
 		entry.data
@@ -255,90 +234,3 @@ function formatTokenCount(tokens: number): string {
 	return tokens < 1000 ? `${tokens}` : `${Math.round(tokens / 1000)}K`;
 }
 
-function liveAgentCard(
-	content: () => string,
-	details: () => AgentCommandDetails | undefined,
-	expanded: boolean,
-	theme: Theme,
-): Component {
-	const body = renderAgentCardBody(content(), details(), expanded, theme);
-	return {
-		render: (width) => renderAgentCard(content(), details(), body, theme).render(width),
-		invalidate: () => body.invalidate(),
-	};
-}
-
-function renderAgentCard(
-	content: string,
-	details: AgentCommandDetails | undefined,
-	body: Component,
-	theme: Theme,
-): Container {
-	const ok = details?.ok ?? !content.includes("<user_agent_error");
-	const command = details ? `/${details.command}` : "/agent";
-	const icon = ok ? theme.fg("success", "✓") : theme.fg("error", "✗");
-	const statusText = ok ? theme.fg("dim", "completed") : theme.fg("error", "failed");
-	const parts = buildRendererParts(content, details);
-	const task = details?.task ?? extractTag(content, "task");
-
-	let text = `${icon} ${theme.bold(command)} ${statusText}`;
-	if (parts.length > 0) text += ` ${theme.fg("dim", "·")} ${theme.fg("dim", parts.join(" · "))}`;
-	if (task) text += `\n  ${theme.fg("dim", `task: ${truncatePlain(task, 88)}`)}`;
-	const card = new Container();
-	card.addChild(new Text(text, 1, 0));
-	card.addChild(body);
-	return card;
-}
-
-function renderAgentCardBody(
-	content: string,
-	details: AgentCommandDetails | undefined,
-	expanded: boolean,
-	theme: Theme,
-): Component {
-	const ok = details?.ok ?? !content.includes("<user_agent_error");
-	const output =
-		details?.responseText ??
-		details?.error ??
-		extractTag(content, ok ? "response" : "error") ??
-		"No output.";
-	if (expanded)
-		return ok
-			? new Markdown(output, 3, 0, getMarkdownTheme())
-			: new Text(theme.fg("error", output), 3, 0);
-
-	const previewText = `⎿  ${truncatePlain(details?.responsePreview ?? output, 110)}`;
-	if (!ok) return new Text(`  ${theme.fg("error", previewText)}`, 1, 0);
-	return new Markdown(previewText, 3, 0, getMarkdownTheme(), {
-		color: (value) => theme.fg("dim", value),
-	});
-}
-
-function customMessageContentText(content: unknown): string {
-	if (typeof content === "string") return content;
-	if (!Array.isArray(content)) return String(content ?? "");
-	return content
-		.filter(
-			(part): part is { type: "text"; text: string } =>
-				part?.type === "text" && typeof part.text === "string",
-		)
-		.map((part) => part.text)
-		.join("\n");
-}
-
-function buildRendererParts(content: string, details: AgentCommandDetails | undefined): string[] {
-	const parts: string[] = [];
-	if (details?.modelLabel) parts.push(details.modelLabel);
-	else if (details?.model) parts.push(details.model);
-	if (details?.inheritedContext !== undefined) parts.push(contextLabel(details.inheritedContext));
-	const mainContext = mainContextLabel(details?.mainContextState);
-	if (mainContext) parts.push(mainContext);
-	if (details?.turnCount) parts.push(formatTurns(details.turnCount));
-	if (details?.toolUses) parts.push(formatToolUses(details.toolUses));
-	if (details?.durationMs !== undefined) parts.push(formatMs(details.durationMs));
-	else {
-		const duration = extractTag(content, "duration_ms");
-		if (duration) parts.push(formatMs(Number(duration)));
-	}
-	return parts;
-}

package/widget.ts

@@ -1,3 +1,4 @@
+import * as childProcess from "node:child_process";
 import {
 	isKeyRelease,
 	matchesKey,
@@ -17,6 +18,7 @@ import {
 import { renderAgentContextMeter } from "./context-meter.js";
 import { selectRebaseMessages } from "./rebase.js";
 import type {
+	AgentMessage,
 	AgentResultMessage,
 	CompletedAgent,
 	RebaseDelivery,
@@ -25,6 +27,7 @@ import type {
 	UIContext,
 } from "./shared.js";
 import {
+	CONFIRMATION_WINDOW_MS,
 	contextLabel,
 	formatMs,
 	TimedConfirmation,
@@ -42,6 +45,19 @@ type UserAgentWidgetEntry =
 	| { kind: "running"; startedAt: number; agent: RunningAgent }
 	| { kind: "completed"; startedAt: number; agent: CompletedAgent };
 
+type CachedActivityPreview = {
+	source: AgentMessage | string | undefined;
+	status: RunningAgent["status"] | boolean;
+	error: string | undefined;
+	width: number;
+	theme: Theme;
+	text: string;
+};
+
+type CopyTarget = "response" | "session-id";
+
+const COPY_FEEDBACK_MS = 1500;
+
 export class UserAgentWidget {
 	private ui: UIContext | undefined;
 	private frame = 0;
@@ -52,8 +68,13 @@ export class UserAgentWidget {
 	private active = false;
 	private selectedIndex = 0;
 	private viewerOpen = false;
-	/** One confirmation slot for detaching the selected agent. */
-	private readonly detachConfirmation = new TimedConfirmation<ViewableAgent>(() => this.update());
+	private copied: { agentId: string; target: CopyTarget } | undefined;
+	private copiedTimer: ReturnType<typeof setTimeout> | undefined;
+	private rebaseWarning: { agentId: string; text: string } | undefined;
+	private rebaseWarningTimer: ReturnType<typeof setTimeout> | undefined;
+	private activityPreviews = new WeakMap<ViewableAgent, CachedActivityPreview>();
+	/** One confirmation slot for both destructive selected-row actions. */
+	private readonly confirmation = new TimedConfirmation<string>(() => this.update());
 	private readonly completedAgents: CompletedAgent[] = [];
 
 	constructor(
@@ -67,9 +88,10 @@ export class UserAgentWidget {
 		if (ui === this.ui) return;
 		this.inputUnsub?.();
 		this.ui = ui;
+		this.activityPreviews = new WeakMap();
 		this.widgetRegistered = false;
 		this.tui = undefined;
-		this.detachConfirmation.cancel();
+		this.confirmation.cancel();
 		this.inputUnsub = ui.onTerminalInput((data) => this.handleKey(data));
 	}
 
@@ -101,12 +123,18 @@ export class UserAgentWidget {
 	}
 
 	ensureTimer(): void {
-		if (!this.ui || this.interval) return;
-		this.interval = setInterval(() => this.update(), 100);
+		const active = [...this.runningAgents].some(isLiveAgent);
+		if (!active && this.interval) {
+			clearInterval(this.interval);
+			this.interval = undefined;
+		}
+		if (!this.ui || !active || this.interval) return;
+		this.interval = setInterval(() => this.update(), 200);
 	}
 
 	update(): void {
 		if (!this.ui) return;
+		this.ensureTimer();
 		const entries = this.entries();
 		if (entries.length === 0) {
 			this.clear();
@@ -123,8 +151,7 @@ export class UserAgentWidget {
 					return {
 						render: (width: number) => this.renderWidget(width, theme),
 						invalidate: () => {
-							this.widgetRegistered = false;
-							this.tui = undefined;
+							this.activityPreviews = new WeakMap();
 						},
 					};
 				},
@@ -148,7 +175,8 @@ export class UserAgentWidget {
 		this.widgetRegistered = false;
 		this.tui = undefined;
 		this.active = false;
-		this.detachConfirmation.cancel();
+		this.activityPreviews = new WeakMap();
+		this.confirmation.cancel();
 	}
 
 	private clear(): void {
@@ -163,7 +191,7 @@ export class UserAgentWidget {
 		}
 		this.active = false;
 		this.selectedIndex = 0;
-		this.detachConfirmation.cancel();
+		this.confirmation.cancel();
 	}
 
 	private runningAgentsForWidget(): RunningAgent[] {
@@ -207,13 +235,13 @@ export class UserAgentWidget {
 		}
 
 		if (matchesKey(data, "down")) {
-			this.detachConfirmation.cancel();
+			this.confirmation.cancel();
 			this.selectedIndex = Math.min(entries.length - 1, this.selectedIndex + 1);
 			this.update();
 			return { consume: true };
 		}
 		if (matchesKey(data, "up")) {
-			this.detachConfirmation.cancel();
+			this.confirmation.cancel();
 			if (this.selectedIndex === 0) {
 				this.deactivate();
 				return { consume: true };
@@ -228,20 +256,40 @@ export class UserAgentWidget {
 		}
 
 		const selected = entries[this.selectedIndex];
+		if (!matchesKey(data, "d") && !matchesKey(data, "r")) this.confirmation.cancel();
 		if (
 			matchesKey(data, "ctrl+x") &&
 			selected?.kind === "running" &&
 			isLiveAgent(selected.agent)
 		) {
-			this.detachConfirmation.cancel();
 			this.interruptRunning(selected.agent);
 			return { consume: true };
 		}
 		if (matchesKey(data, "enter")) {
-			this.detachConfirmation.cancel();
 			if (selected) this.openSelected(selected.agent);
 			return { consume: true };
 		}
+		if (matchesKey(data, "c") && selected) {
+			const text =
+				isRunningAgent(selected.agent) || selected.agent.ok
+					? selected.agent.responseText
+					: (selected.agent.error ?? "");
+			this.copyToClipboard(selected.agent.id, text, "response");
+			return { consume: true };
+		}
+		if (matchesKey(data, "i") && selected) {
+			this.copyToClipboard(selected.agent.id, selected.agent.sessionId, "session-id");
+			return { consume: true };
+		}
+		if (matchesKey(data, "s")) {
+			if (selected && this.canSquashMainContext(selected.agent.id))
+				this.squashMainContext(selected.agent.id);
+			return { consume: true };
+		}
+		if (matchesKey(data, "r")) {
+			this.requestRebase(selected);
+			return { consume: true };
+		}
 		if (matchesKey(data, "d") && selected) {
 			if (!this.confirmDetach(selected.agent)) return { consume: true };
 			if (selected.kind === "running") this.closeRunning(selected.agent);
@@ -254,15 +302,64 @@ export class UserAgentWidget {
 	}
 
 	private confirmDetach(target: ViewableAgent): boolean {
-		const confirmed = this.detachConfirmation.press(target);
+		const confirmed = this.confirmation.press(`detach:${target.id}`);
 		if (!confirmed) this.update();
 		return confirmed;
 	}
 
+	private requestRebase(selected: UserAgentWidgetEntry | undefined): void {
+		if (!selected) return;
+		const agentId = selected.agent.id;
+		const reason = this.rebaseBlockReason(agentId);
+		if (reason) {
+			this.confirmation.cancel();
+			this.showRebaseWarning(agentId, `Can't rebase: ${reason}`);
+			return;
+		}
+		if (!this.deliverableAgent(agentId)) {
+			this.confirmation.cancel();
+			return;
+		}
+		if (
+			this.rebaseDetachCount(agentId) > 0 &&
+			!this.confirmation.press(`rebase:${agentId}`)
+		) {
+			this.update();
+			return;
+		}
+		this.rebaseMainContext(agentId);
+	}
+
+	private copyToClipboard(agentId: string, text: string, target: CopyTarget): void {
+		const child = childProcess.execFile("pbcopy", (error) => {
+			if (error) return;
+			this.copied = { agentId, target };
+			if (this.copiedTimer) clearTimeout(this.copiedTimer);
+			this.update();
+			this.copiedTimer = setTimeout(() => {
+				this.copied = undefined;
+				this.copiedTimer = undefined;
+				this.update();
+			}, COPY_FEEDBACK_MS);
+		});
+		child.stdin?.end(text);
+	}
+
+	private showRebaseWarning(agentId: string, text: string): void {
+		this.rebaseWarning = { agentId, text };
+		if (this.rebaseWarningTimer) clearTimeout(this.rebaseWarningTimer);
+		this.rebaseWarningTimer = setTimeout(() => {
+			this.rebaseWarning = undefined;
+			this.rebaseWarningTimer = undefined;
+			this.update();
+		}, CONFIRMATION_WINDOW_MS);
+		this.update();
+	}
+
 	private deactivate(): void {
 		this.active = false;
 		this.selectedIndex = 0;
-		this.detachConfirmation.cancel();
+		this.confirmation.cancel();
 		this.update();
 	}
 
@@ -493,24 +590,60 @@ export class UserAgentWidget {
 		} else {
 			const selected = entries[this.selectedIndex];
 			const confirmingDetach =
-				selected !== undefined && this.detachConfirmation.isArmedOn(selected.agent);
-			const segments = [theme.fg("accent", "↑↓ select"), theme.fg("accent", "Enter view")];
-			if (
-				!confirmingDetach &&
-				selected?.kind === "running" &&
-				isLiveAgent(selected.agent)
-			)
-				segments.push(theme.fg("accent", "Ctrl+x interrupt"));
-			segments.push(
-				theme.fg(
-					confirmingDetach ? "error" : "accent",
-					confirmingDetach ? "d again to confirm" : "d detach",
-				),
-				theme.fg("accent", "Esc back"),
-			);
-			lines.push(
-				truncateToWidth(`  ${segments.join(theme.fg("accent", " · "))}`, width),
-			);
+				selected !== undefined &&
+				this.confirmation.isArmedOn(`detach:${selected.agent.id}`);
+			const confirmingRebase =
+				selected !== undefined &&
+				this.confirmation.isArmedOn(`rebase:${selected.agent.id}`);
+			if (confirmingRebase && selected) {
+				const detachCount = this.rebaseDetachCount(selected.agent.id);
+				lines.push(
+					truncateToWidth(
+						`  ${theme.fg(
+							"warning",
+							`⚠ Rebase will detach ${detachCount} other agent session${detachCount === 1 ? "" : "s"}. r again to confirm`,
+						)}`,
+						width,
+					),
+				);
+			} else if (selected && this.rebaseWarning?.agentId === selected.agent.id) {
+				lines.push(
+					truncateToWidth(`  ${theme.fg("warning", `⚠ ${this.rebaseWarning.text}`)}`, width),
+				);
+			} else {
+				const segments = [theme.fg("accent", "↑↓ select"), theme.fg("accent", "Enter view")];
+				if (!confirmingDetach)
+					segments.push(
+						this.copied?.agentId === selected?.agent.id &&
+							this.copied.target === "response"
+							? theme.fg("success", "✓ copied")
+							: theme.fg("accent", "c copy"),
+						this.copied?.agentId === selected?.agent.id &&
+							this.copied.target === "session-id"
+							? theme.fg("success", "✓ copied ID")
+							: theme.fg("accent", "i ID"),
+					);
+				if (!confirmingDetach && selected && this.canSquashMainContext(selected.agent.id))
+					segments.push(theme.fg("accent", "s squash"));
+				if (!confirmingDetach && selected && this.canRebaseMainContext(selected.agent.id))
+					segments.push(theme.fg("accent", "r rebase"));
+				if (
+					!confirmingDetach &&
+					selected?.kind === "running" &&
+					isLiveAgent(selected.agent)
+				)
+					segments.push(theme.fg("accent", "Ctrl+x interrupt"));
+				segments.push(
+					theme.fg(
+						confirmingDetach ? "error" : "accent",
+						confirmingDetach ? "d again to confirm" : "d detach",
+					),
+					theme.fg("accent", "Esc back"),
+				);
+				lines.push(
+					truncateToWidth(`  ${segments.join(theme.fg("accent", " · "))}`, width),
+				);
+			}
 		}
 
 		const maxEntries = Math.max(1, Math.floor((MAX_WIDGET_LINES - lines.length) / 2));
@@ -550,15 +683,17 @@ export class UserAgentWidget {
 		const running = isRunningAgent(agent);
 		const inFlight = isLiveAgent(agent);
 		const ok = running ? agent.error === undefined : agent.ok;
+		const status = inFlight ? "running" : running ? "idle" : ok ? "completed" : "failed";
 		const marker = selected ? theme.fg("accent", "⏺") : theme.fg("dim", "◯");
 		const icon = inFlight
 			? theme.fg("accent", SPINNER[this.frame % SPINNER.length])
-			: ok
-				? theme.fg("success", "✓")
-				: theme.fg("error", "✗");
-		const parts = inFlight
-			? [agent.modelLabel, contextLabel(agent.inheritedContext)]
-			: [agent.modelLabel];
+			: running
+				? theme.fg("muted", "◉")
+				: ok
+					? theme.fg("success", "✓")
+					: theme.fg("error", "✗");
+		const parts = [agent.modelLabel, status];
+		if (inFlight) parts.push(contextLabel(agent.inheritedContext));
 		const mainContext = mainContextLabel(agent.mainContextState);
 		if (mainContext) parts.push(mainContext);
 		if (agent.turnCount > 0) parts.push(formatTurns(agent.turnCount));
@@ -574,6 +709,7 @@ export class UserAgentWidget {
 			marker,
 			icon,
 			theme.bold(`/${agent.command}`),
+			selected ? theme.fg("dim", `ID ${agent.sessionId.slice(0, 8)}`) : "",
 			renderAgentContextMeter(agent, theme),
 			theme.fg("muted", truncatePlain(agent.task, 52)),
 			theme.fg("dim", "·"),
@@ -583,16 +719,30 @@ export class UserAgentWidget {
 			.join(" ");
 		const activityPrefix = `${indent}   ⎿  `;
 		const activityWidth = Math.max(0, width - visibleWidth(activityPrefix));
+		const preview = this.renderActivityPreview(agent, activityWidth, theme);
+		const activityText = ok ? preview : theme.fg("error", preview);
+		const activity = `${theme.fg("dim", indent)}   ${theme.fg("dim", "⎿  ")}${activityText}`;
+		return [truncateToWidth(header, width), truncateToWidth(activity, width)];
+	}
+
+	private renderActivityPreview(agent: ViewableAgent, width: number, theme: Theme): string {
+		const running = isRunningAgent(agent);
+		const source = isLiveAgent(agent) ? agent.latestFinalizedMessage : agent.responseText;
+		const status = running ? agent.status : agent.ok;
+		const cached = this.activityPreviews.get(agent);
+		if (
+			cached && cached.source === source && cached.status === status &&
+			cached.error === agent.error && cached.width === width && cached.theme === theme
+		) return cached.text;
 		const description = running
 			? describeActivity(agent)
 			: {
 					text: agent.ok ? agent.responseText : `Error: ${agent.error ?? "unknown"}`,
 					truncation: "tail" as const,
 				};
-		const preview = renderActivity(description, activityWidth, theme);
-		const activityText = ok ? preview : theme.fg("error", preview);
-		const activity = `${theme.fg("dim", indent)}   ${theme.fg("dim", "⎿  ")}${activityText}`;
-		return [truncateToWidth(header, width), truncateToWidth(activity, width)];
+		const text = renderActivity(description, width, theme);
+		this.activityPreviews.set(agent, { source, status, error: agent.error, width, theme, text });
+		return text;
 	}
 }