lsd-pi 1.2.4 → 1.3.6

package/src/resources/extensions/slash-commands/tools.ts

@@ -48,6 +48,32 @@ function getBalancedToolNames(activeToolNames: string[]): string[] {
         ];
 }
 
+const STANDARD_TOOLS = [
+    // Core
+    "read", "bash", "edit", "write", "lsp", "grep", "find", "ls",
+    // Background
+    "bg_shell",
+    // Search
+    "web_search", "fetch_page",
+    // Docs
+    "resolve_library", "get_library_docs",
+    // Agent
+    "subagent", "await_subagent", "Skill",
+    // User interaction
+    "ask_user_questions", "secure_env_collect",
+    // Browser (essential)
+    "browser_navigate", "browser_click", "browser_type", "browser_screenshot",
+    "browser_scroll", "browser_key_press", "browser_evaluate",
+    "browser_find", "browser_wait_for", "browser_close",
+    "browser_assert", "browser_batch",
+    // Tool management
+    "tool_search", "tool_enable",
+];
+
+function getStandardToolNames(): string[] {
+    return [...STANDARD_TOOLS];
+}
+
 function getFullToolNames(pi: ExtensionAPI): string[] {
     return pi.getAllTools().map((tool) => tool.name).filter((name): name is string => Boolean(name));
 }
@@ -180,7 +206,8 @@ export default function toolSearchExtension(pi: ExtensionAPI) {
                         currentActive.length > 0 ? currentActive.join(", ") : "(none)",
                         "",
                         "Usage:",
-                        "  /tools balanced   Switch to the balanced tool profile",
+                        "  /tools balanced   Switch to the balanced tool profile (12 tools)",
+                        "  /tools standard   Switch to the standard tool profile (~32 tools)",
                         "  /tools full       Switch to the full tool profile (all available tools)",
                         "  /tools on         Alias for /tools full",
                         "  /tools off        Alias for /tools balanced",
@@ -196,7 +223,19 @@ export default function toolSearchExtension(pi: ExtensionAPI) {
                 pi.setActiveTools(nextActive);
                 pi.sendMessage({
                     customType: "tools:mode",
-                    content: `Balanced tool profile active: ${pi.getActiveTools().join(", ")}`,
+                    content: `Balanced tool profile active (${pi.getActiveTools().length} tools): ${pi.getActiveTools().join(", ")}`,
+                    display: true,
+                });
+                return;
+            }
+
+            if (input === "standard") {
+                settings.setToolProfile("standard");
+                const nextActive = getStandardToolNames();
+                pi.setActiveTools(nextActive);
+                pi.sendMessage({
+                    customType: "tools:mode",
+                    content: `Standard tool profile active (${pi.getActiveTools().length} tools): ${pi.getActiveTools().join(", ")}`,
                     display: true,
                 });
                 return;
@@ -208,7 +247,7 @@ export default function toolSearchExtension(pi: ExtensionAPI) {
                 pi.setActiveTools(nextActive);
                 pi.sendMessage({
                     customType: "tools:mode",
-                    content: `Full tool profile active: ${pi.getActiveTools().join(", ")}`,
+                    content: `Full tool profile active (${pi.getActiveTools().length} tools): ${pi.getActiveTools().join(", ")}`,
                     display: true,
                 });
                 return;
@@ -216,7 +255,7 @@ export default function toolSearchExtension(pi: ExtensionAPI) {
 
             pi.sendMessage({
                 customType: "tools:help",
-                content: `Unknown /tools subcommand: ${input}\n\nTry /tools, /tools balanced, /tools full, /tools on, or /tools off.`,
+                content: `Unknown /tools subcommand: ${input}\n\nTry /tools, /tools balanced, /tools standard, /tools full, /tools on, or /tools off.`,
                 display: true,
             });
         },

package/src/resources/extensions/subagent/agent-switcher-component.ts

@@ -0,0 +1,228 @@
+import type { ExtensionCommandContext, Theme } from "@gsd/pi-coding-agent";
+import { Key, matchesKey, truncateToWidth, visibleWidth } from "@gsd/pi-tui";
+import type { AgentSwitchTarget } from "./agent-switcher-model.js";
+
+const MAX_VISIBLE_ROWS = 10;
+
+function stateIcon(theme: Theme, target: AgentSwitchTarget): string {
+	if (target.kind === "parent") return theme.fg("accent", "●");
+	if (target.state === "running") return theme.fg("warning", "▶");
+	if (target.state === "failed") return theme.fg("error", "✗");
+	return theme.fg("success", "✓");
+}
+
+function stateBadge(theme: Theme, target: AgentSwitchTarget): string {
+	if (target.kind === "parent") return theme.fg("muted", "parent");
+	if (target.state === "running") return theme.fg("warning", "running");
+	if (target.state === "failed") return theme.fg("error", "failed");
+	return theme.fg("success", "completed");
+}
+
+function plainLabel(target: AgentSwitchTarget): string {
+	if (target.kind === "parent") {
+		const currentSuffix = target.isCurrent ? " (current)" : "";
+		return `● parent — main session${currentSuffix}`;
+	}
+	const icon = target.state === "running" ? "▶" : target.state === "failed" ? "✗" : "✓";
+	const currentSuffix = target.isCurrent ? " (current)" : "";
+	return `${icon} ${target.agentName} — ${target.taskPreview}${currentSuffix}`;
+}
+
+class AgentSwitcherComponent {
+	private readonly tui: { requestRender: () => void };
+	private readonly theme: Theme;
+	private readonly targets: AgentSwitchTarget[];
+	private readonly done: (result: AgentSwitchTarget | undefined) => void;
+	private selectedIndex: number;
+	private statusLine: string | undefined;
+	private cachedWidth?: number;
+	private cachedLines?: string[];
+
+	constructor(
+		tui: { requestRender: () => void },
+		theme: Theme,
+		targets: AgentSwitchTarget[],
+		done: (result: AgentSwitchTarget | undefined) => void,
+	) {
+		this.tui = tui;
+		this.theme = theme;
+		this.targets = targets;
+		this.done = done;
+		this.selectedIndex = this.getInitialSelectionIndex();
+	}
+
+	private getInitialSelectionIndex(): number {
+		const firstSwitchable = this.targets.findIndex((target) => target.selectionAction !== "blocked");
+		return firstSwitchable >= 0 ? firstSwitchable : 0;
+	}
+
+	private move(delta: number): void {
+		if (this.targets.length === 0) return;
+		const next = Math.max(0, Math.min(this.targets.length - 1, this.selectedIndex + delta));
+		if (next === this.selectedIndex) return;
+		this.selectedIndex = next;
+		this.statusLine = undefined;
+		this.invalidate();
+		this.tui.requestRender();
+	}
+
+	handleInput(data: string): void {
+		if (matchesKey(data, Key.escape) || matchesKey(data, Key.ctrl("c"))) {
+			this.done(undefined);
+			return;
+		}
+		if (matchesKey(data, Key.up)) {
+			this.move(-1);
+			return;
+		}
+		if (matchesKey(data, Key.down)) {
+			this.move(1);
+			return;
+		}
+		if (matchesKey(data, Key.pageUp)) {
+			this.move(-MAX_VISIBLE_ROWS);
+			return;
+		}
+		if (matchesKey(data, Key.pageDown)) {
+			this.move(MAX_VISIBLE_ROWS);
+			return;
+		}
+		if (matchesKey(data, Key.enter) || matchesKey(data, Key.space)) {
+			const selected = this.targets[this.selectedIndex];
+			if (!selected) {
+				this.done(undefined);
+				return;
+			}
+			if (selected.selectionAction === "blocked") {
+				this.statusLine = selected.blockedReason ?? "This row cannot be selected yet.";
+				this.invalidate();
+				this.tui.requestRender();
+				return;
+			}
+			this.done(selected);
+		}
+	}
+
+	private getVisibleWindow(): { start: number; end: number } {
+		if (this.targets.length <= MAX_VISIBLE_ROWS) return { start: 0, end: this.targets.length };
+		const half = Math.floor(MAX_VISIBLE_ROWS / 2);
+		let start = Math.max(0, this.selectedIndex - half);
+		let end = Math.min(this.targets.length, start + MAX_VISIBLE_ROWS);
+		if (end - start < MAX_VISIBLE_ROWS) {
+			start = Math.max(0, end - MAX_VISIBLE_ROWS);
+		}
+		return { start, end };
+	}
+
+	private renderRow(target: AgentSwitchTarget, isSelected: boolean, width: number): string {
+		const cursor = isSelected ? this.theme.fg("accent", "▸") : " ";
+		const icon = stateIcon(this.theme, target);
+		const baseLabel = target.kind === "parent"
+			? "parent — main session"
+			: `${target.agentName} — ${target.taskPreview}`;
+		const currentTag = target.isCurrent ? this.theme.fg("accent", "(current)") : "";
+		const badge = stateBadge(this.theme, target);
+		const right = [currentTag, badge].filter(Boolean).join(" ");
+
+		const leftRaw = `${cursor} ${icon} ${baseLabel}`;
+		const rightWidth = right ? visibleWidth(right) + 1 : 0;
+		const maxLeft = Math.max(10, width - 4 - rightWidth);
+		const left = truncateToWidth(leftRaw, maxLeft, "…");
+		const spacing = Math.max(1, width - 4 - visibleWidth(left) - visibleWidth(right));
+		const composed = `${left}${" ".repeat(spacing)}${right}`;
+
+		if (!isSelected) {
+			if (target.selectionAction === "blocked") return this.theme.fg("dim", composed);
+			return composed;
+		}
+		return this.theme.bold(composed);
+	}
+
+	private box(inner: string[], width: number): string[] {
+		const bdr = (s: string) => this.theme.fg("borderMuted", s);
+		const iw = width - 4;
+		const lines: string[] = [];
+		lines.push(bdr("╭" + "─".repeat(width - 2) + "╮"));
+		for (const line of inner) {
+			const truncated = truncateToWidth(line, iw, "…");
+			const pad = Math.max(0, iw - visibleWidth(truncated));
+			lines.push(bdr("│") + " " + truncated + " ".repeat(pad) + " " + bdr("│"));
+		}
+		lines.push(bdr("╰" + "─".repeat(width - 2) + "╯"));
+		return lines;
+	}
+
+	render(width: number): string[] {
+		if (this.cachedLines && this.cachedWidth === width) return this.cachedLines;
+		const inner: string[] = [];
+		inner.push(this.theme.bold(this.theme.fg("accent", "Agent session switcher")));
+		inner.push(this.theme.fg("dim", "Parent + tracked subagents"));
+		inner.push("");
+
+		if (this.targets.length === 0) {
+			inner.push(this.theme.fg("dim", "No switch targets available."));
+		} else {
+			const { start, end } = this.getVisibleWindow();
+			for (let i = start; i < end; i++) {
+				inner.push(this.renderRow(this.targets[i]!, i === this.selectedIndex, width));
+			}
+			if (start > 0 || end < this.targets.length) {
+				inner.push("");
+				inner.push(this.theme.fg("dim", `${this.selectedIndex + 1}/${this.targets.length}`));
+			}
+		}
+
+		inner.push("");
+		const actionHint = this.targets[this.selectedIndex]?.selectionAction === "attach_live"
+			? "Enter attach live"
+			: "Enter switch";
+		inner.push(this.theme.fg("dim", `${actionHint} · Esc cancel`));
+		if (this.statusLine) {
+			inner.push(this.theme.fg("warning", this.statusLine));
+		}
+
+		this.cachedLines = this.box(inner, width);
+		this.cachedWidth = width;
+		return this.cachedLines;
+	}
+
+	invalidate(): void {
+		this.cachedWidth = undefined;
+		this.cachedLines = undefined;
+	}
+}
+
+export async function showAgentSwitcher(
+	ctx: ExtensionCommandContext,
+	targets: AgentSwitchTarget[],
+): Promise<AgentSwitchTarget | undefined> {
+	const result = await ctx.ui.custom<AgentSwitchTarget | undefined>(
+		(tui, theme, _kb, done) => new AgentSwitcherComponent(tui, theme, targets, done),
+		{
+			overlay: true,
+			overlayOptions: {
+				anchor: "center",
+				width: "65%",
+				minWidth: 60,
+				maxHeight: "70%",
+			},
+		},
+	);
+
+	if (result !== undefined && result !== null) {
+		return result;
+	}
+
+	if (targets.length === 0) return undefined;
+	const labels = targets.map((target, index) => `${index + 1}. ${plainLabel(target)}`);
+	const selected = await ctx.ui.select("Switch agent session", labels);
+	if (!selected || Array.isArray(selected)) return undefined;
+	const selectedIndex = labels.indexOf(selected);
+	if (selectedIndex < 0) return undefined;
+	const target = targets[selectedIndex]!;
+	if (target.selectionAction === "blocked") {
+		ctx.ui.notify(target.blockedReason ?? "That target is not selectable yet.", "warning");
+		return undefined;
+	}
+	return target;
+}

package/src/resources/extensions/subagent/agent-switcher-model.ts

@@ -0,0 +1,160 @@
+export type AgentSwitchTargetKind = "parent" | "subagent";
+export type AgentSwitchTargetState = "running" | "completed" | "failed";
+export type AgentSwitchTargetSelectionAction = "switch_saved" | "attach_live" | "blocked";
+
+export interface AgentSwitchTarget {
+	id: string;
+	kind: AgentSwitchTargetKind;
+	sessionFile: string;
+	parentSessionFile?: string;
+	agentName: string;
+	taskPreview: string;
+	state: AgentSwitchTargetState;
+	isCurrent: boolean;
+	isLiveAttachCapable: boolean;
+	selectionAction: AgentSwitchTargetSelectionAction;
+	blockedReason?: string;
+	runningJobId?: string;
+	sortTime: number;
+}
+
+export interface AgentSwitchSessionLinkRecord {
+	id: string;
+	agentName: string;
+	task: string;
+	parentSessionFile: string;
+	subagentSessionFile: string;
+	updatedAt: number;
+	state: AgentSwitchTargetState;
+}
+
+export interface AgentSwitchRunningJobRecord {
+	id: string;
+	agentName: string;
+	task: string;
+	startedAt: number;
+	parentSessionFile?: string;
+	sessionFile?: string;
+	cwd?: string;
+}
+
+export interface BuildAgentSwitchTargetsInput {
+	currentSessionFile: string;
+	rootParentSessionFile: string;
+	currentCwd?: string;
+	trackedLinks: AgentSwitchSessionLinkRecord[];
+	runningJobs: AgentSwitchRunningJobRecord[];
+}
+
+function summarizeTask(task: string, max = 72): string {
+	const trimmed = task.replace(/\s+/g, " ").trim();
+	if (!trimmed) return "(no task)";
+	return trimmed.length > max ? `${trimmed.slice(0, max)}…` : trimmed;
+}
+
+function stateRank(state: AgentSwitchTargetState): number {
+	if (state === "running") return 0;
+	if (state === "completed") return 1;
+	return 2;
+}
+
+function shouldIncludeRunningJob(
+	job: AgentSwitchRunningJobRecord,
+	rootParentSessionFile: string,
+	currentCwd?: string,
+): boolean {
+	if (job.parentSessionFile) return job.parentSessionFile === rootParentSessionFile;
+	if (currentCwd && job.cwd) return currentCwd === job.cwd;
+	return false;
+}
+
+export function buildAgentSwitchTargets(input: BuildAgentSwitchTargetsInput): AgentSwitchTarget[] {
+	const targetsBySessionFile = new Map<string, AgentSwitchTarget>();
+
+	for (const link of input.trackedLinks) {
+		const canAttachLive = link.state === "running";
+		targetsBySessionFile.set(link.subagentSessionFile, {
+			id: link.id,
+			kind: "subagent",
+			sessionFile: link.subagentSessionFile,
+			parentSessionFile: link.parentSessionFile,
+			agentName: link.agentName,
+			taskPreview: summarizeTask(link.task),
+			state: link.state,
+			isCurrent: link.subagentSessionFile === input.currentSessionFile,
+			isLiveAttachCapable: canAttachLive,
+			selectionAction: link.state === "running" ? (canAttachLive ? "attach_live" : "blocked") : "switch_saved",
+			blockedReason: link.state === "running" && !canAttachLive
+				? "Live attach is not implemented yet for running subagents."
+				: undefined,
+			sortTime: link.updatedAt,
+		});
+	}
+
+	const runningExtras: AgentSwitchTarget[] = [];
+	for (const job of input.runningJobs) {
+		if (!shouldIncludeRunningJob(job, input.rootParentSessionFile, input.currentCwd)) continue;
+
+		if (job.sessionFile && targetsBySessionFile.has(job.sessionFile)) {
+			const existing = targetsBySessionFile.get(job.sessionFile)!;
+			existing.state = "running";
+			existing.isLiveAttachCapable = true;
+			existing.selectionAction = "attach_live";
+			existing.blockedReason = undefined;
+			existing.runningJobId = job.id;
+			existing.sortTime = Math.max(existing.sortTime, job.startedAt);
+			continue;
+		}
+
+		const canAttachLive = Boolean(job.sessionFile);
+		const syntheticSessionFile = job.sessionFile ?? `${input.rootParentSessionFile}#${job.id}`;
+		runningExtras.push({
+			id: job.id,
+			kind: "subagent",
+			sessionFile: syntheticSessionFile,
+			parentSessionFile: job.parentSessionFile ?? input.rootParentSessionFile,
+			agentName: job.agentName,
+			taskPreview: summarizeTask(job.task),
+			state: "running",
+			isCurrent: Boolean(job.sessionFile && job.sessionFile === input.currentSessionFile),
+			isLiveAttachCapable: canAttachLive,
+			selectionAction: canAttachLive ? "attach_live" : "blocked",
+			blockedReason: canAttachLive ? undefined : "Live attach is not implemented yet for running subagents.",
+			runningJobId: job.id,
+			sortTime: job.startedAt,
+		});
+	}
+
+	const parentTarget: AgentSwitchTarget = {
+		id: "parent",
+		kind: "parent",
+		sessionFile: input.rootParentSessionFile,
+		agentName: "parent",
+		taskPreview: "Main session",
+		state: "completed",
+		isCurrent: input.currentSessionFile === input.rootParentSessionFile,
+		isLiveAttachCapable: false,
+		selectionAction: input.currentSessionFile === input.rootParentSessionFile ? "blocked" : "switch_saved",
+		blockedReason: input.currentSessionFile === input.rootParentSessionFile
+			? "You are already in the parent/main session."
+			: undefined,
+		sortTime: Number.MAX_SAFE_INTEGER,
+	};
+
+	const targets = [
+		parentTarget,
+		...targetsBySessionFile.values(),
+		...runningExtras,
+	];
+
+	targets.sort((a, b) => {
+		if (a.isCurrent !== b.isCurrent) return a.isCurrent ? -1 : 1;
+		if (a.kind !== b.kind) return a.kind === "parent" ? -1 : 1;
+		const stateDiff = stateRank(a.state) - stateRank(b.state);
+		if (stateDiff !== 0) return stateDiff;
+		if (a.sortTime !== b.sortTime) return b.sortTime - a.sortTime;
+		return a.agentName.localeCompare(b.agentName);
+	});
+
+	return targets;
+}

package/src/resources/extensions/subagent/background-job-manager.ts

@@ -16,6 +16,26 @@ import type {
 
 export type { BackgroundSubagentJob, BackgroundJobStatus };
 
+type BackgroundJobResult = {
+    summary: string;
+    stderr: string;
+    exitCode: number;
+    model?: string;
+    sessionFile?: string;
+    parentSessionFile?: string;
+};
+
+type BackgroundJobMetadata = {
+    parentSessionFile?: string;
+    sessionFile?: string;
+    model?: string;
+};
+
+type InProcessHandleLike = {
+    abort: () => void;
+    dispose: () => void;
+};
+
 export class BackgroundJobManager {
     private jobs = new Map<string, BackgroundSubagentJob>();
     private evictionTimers = new Map<string, ReturnType<typeof setTimeout>>();
@@ -44,10 +64,11 @@ export class BackgroundJobManager {
         agentName: string,
         task: string,
         cwd: string,
-        runFn: (signal: AbortSignal) => Promise<{ summary: string; stderr: string; exitCode: number; model?: string }>,
+        runFn: (signal: AbortSignal) => Promise<BackgroundJobResult>,
+        metadata?: BackgroundJobMetadata,
     ): string {
         const abortController = new AbortController();
-        return this.attachJob(agentName, task, cwd, abortController, runFn(abortController.signal));
+        return this.attachJob(agentName, task, cwd, abortController, runFn(abortController.signal), metadata);
     }
 
     /**
@@ -58,9 +79,33 @@ export class BackgroundJobManager {
         task: string,
         cwd: string,
         abortController: AbortController,
-        resultPromise: Promise<{ summary: string; stderr: string; exitCode: number; model?: string }>,
+        resultPromise: Promise<BackgroundJobResult>,
+        metadata?: BackgroundJobMetadata,
+    ): string {
+        return this.attachJob(agentName, task, cwd, abortController, resultPromise, metadata);
+    }
+
+    /**
+     * Adopt an in-process subagent handle into background tracking.
+     */
+    adoptHandle(
+        agentName: string,
+        task: string,
+        cwd: string,
+        handle: InProcessHandleLike,
+        resultPromise: Promise<BackgroundJobResult>,
+        metadata?: BackgroundJobMetadata,
     ): string {
-        return this.attachJob(agentName, task, cwd, abortController, resultPromise);
+        const abortController = new AbortController();
+        const onAbort = () => handle.abort();
+        abortController.signal.addEventListener("abort", onAbort, { once: true });
+
+        const wrapped = resultPromise.finally(() => {
+            abortController.signal.removeEventListener("abort", onAbort);
+            handle.dispose();
+        });
+
+        return this.attachJob(agentName, task, cwd, abortController, wrapped, metadata);
     }
 
     /**
@@ -121,7 +166,8 @@ export class BackgroundJobManager {
         task: string,
         cwd: string,
         abortController: AbortController,
-        resultPromise: Promise<{ summary: string; stderr: string; exitCode: number; model?: string }>,
+        resultPromise: Promise<BackgroundJobResult>,
+        metadata?: BackgroundJobMetadata,
     ): string {
         const running = this.getRunningJobs();
         if (running.length >= this.maxRunning) {
@@ -148,18 +194,23 @@ export class BackgroundJobManager {
             cwd,
             status: "running",
             startedAt: Date.now(),
+            model: metadata?.model,
+            sessionFile: metadata?.sessionFile,
+            parentSessionFile: metadata?.parentSessionFile,
             abortController,
             promise: undefined as unknown as Promise<void>,
         };
 
         job.promise = resultPromise
-            .then(({ summary, stderr, exitCode, model }) => {
+            .then(({ summary, stderr, exitCode, model, sessionFile, parentSessionFile }) => {
                 job.status = exitCode === 0 ? "completed" : "failed";
                 job.completedAt = Date.now();
                 job.resultSummary = summary;
                 job.stderr = stderr;
                 job.exitCode = exitCode;
                 job.model = model;
+                job.sessionFile = sessionFile;
+                job.parentSessionFile = parentSessionFile;
                 this.scheduleEviction(id);
                 this.deliverResult(job);
             })

package/src/resources/extensions/subagent/background-runner.ts

@@ -13,6 +13,7 @@ import type { AgentConfig } from "./agents.js";
 export interface BackgroundLaunchContext {
 	defaultCwd: string;
 	model?: { provider: string; id: string };
+	parentSessionFile?: string;
 }
 
 /**
@@ -38,6 +39,8 @@ export function runSubagentInBackground(
 		finalOutput: string;
 		stderr: string;
 		model?: string;
+		sessionFile?: string;
+		parentSessionFile?: string;
 	}>,
 ): string {
 	const effectiveCwd = cwd ?? ctx.defaultCwd;
@@ -61,8 +64,13 @@ export function runSubagentInBackground(
 				stderr: result.stderr,
 				exitCode: result.exitCode,
 				model: result.model,
+				sessionFile: result.sessionFile,
+				parentSessionFile: result.parentSessionFile,
 			};
 		},
+		{
+			parentSessionFile: ctx.parentSessionFile,
+		},
 	);
 
 	return jobId;

package/src/resources/extensions/subagent/background-types.ts

@@ -31,6 +31,10 @@ export interface BackgroundSubagentJob {
 	stderr?: string;
 	/** Model used by the subagent (if known) */
 	model?: string;
+	/** Session file created by the subagent run (if sessions are enabled) */
+	sessionFile?: string;
+	/** Parent session file this subagent was launched from (if known) */
+	parentSessionFile?: string;
 	/**
 	 * Set by await_job-style consumers when they've already consumed the result.
 	 * Suppresses the follow-up delivery.