@ferris1225/pi-subagents 4.3.4 → 4.3.5

package/src/configuration/setup.ts

@@ -0,0 +1,375 @@
+/**
+ * Interactive configuration wizard for /subagents-setup.
+ *
+ * The top-level menu exposes enabled roles, per-agent model and thinking choices,
+ * and a full setup pass. Everything else (agent scope, idle timeout, result lines)
+ * is config-file-only.
+ */
+
+import { stat } from "node:fs/promises";
+import type { Api, Model } from "@earendil-works/pi-ai";
+import type { ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+import {
+	AGENT_PROFILES,
+	BUILTIN_AGENT_NAMES,
+	DEFAULT_CONFIG,
+	DEFAULT_ENABLED_AGENTS,
+	agentProfile,
+	errorMessage,
+	getConfigPath,
+	loadConfig,
+	roleThinkingLevel,
+	saveConfig,
+	type SubagentsConfig,
+	type ThinkingLevel,
+} from "./config.ts";
+import {
+	CURRENT_MAIN_MODEL,
+	applyAgentModelChoice,
+	availableModelsInScope,
+	buildModelPickerItems,
+	currentModelRef,
+	findModelByRef,
+	modelRef,
+	resolveThinkingLevel,
+	supportedThinkingLevels,
+} from "./models.ts";
+import { promptSelectMany, promptSelectOne } from "./ui.ts";
+
+const THINKING_LEVEL_HINTS: Record<ThinkingLevel, string> = {
+	off: "no reasoning tokens",
+	minimal: "minimal reasoning",
+	low: "light reasoning",
+	medium: "balanced reasoning",
+	high: "deep reasoning",
+	xhigh: "extra-deep reasoning",
+	max: "strongest reasoning",
+};
+
+function setupAgentNames(config: SubagentsConfig): string[] {
+	return [
+		...new Set([
+			...BUILTIN_AGENT_NAMES,
+			...config.knownAgents,
+			...config.enabledAgents,
+			...Object.keys(config.agentModels),
+			...Object.keys(config.agentThinkingLevels),
+		]),
+	];
+}
+
+function agentPickerItems(names: readonly string[]): Array<{ value: string; label: string; description: string }> {
+	return names.map((name) => {
+		const profile = agentProfile(name);
+		return {
+			value: name,
+			label: profile ? name : `${name} (custom)`,
+			description: profile ? `${profile.summary} — ${profile.remark}` : "custom agent",
+		};
+	});
+}
+
+function moduleLabel(name: string): string {
+	const profile = agentProfile(name);
+	return profile ? `${name} — ${profile.summary}` : `${name} (custom)`;
+}
+
+async function configExists(configPath: string): Promise<boolean> {
+	try {
+		await stat(configPath);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+async function pickEnabledAgents(
+	ctx: ExtensionCommandContext,
+	config: SubagentsConfig,
+): Promise<string[] | undefined> {
+	return promptSelectMany(
+		ctx,
+		"Which agents should run?",
+		"Each line is a role and its job. Space toggles • Enter confirms • Esc back",
+		agentPickerItems(setupAgentNames(config)),
+		config.enabledAgents,
+	);
+}
+
+async function pickConfiguredModel(
+	ctx: ExtensionCommandContext,
+	title: string,
+	configuredRef: string | undefined,
+	escNote: string,
+): Promise<string | undefined> {
+	const models = availableModelsInScope(ctx);
+	const items = buildModelPickerItems({
+		models,
+		configuredRef,
+		mainRef: currentModelRef(ctx),
+	});
+	return promptSelectOne(
+		ctx,
+		title,
+		`Type to filter by provider, model, or capability • ↑/↓ • Enter selects • Esc ${escNote}`,
+		items,
+		configuredRef ?? CURRENT_MAIN_MODEL,
+	);
+}
+
+async function pickAgentModel(
+	ctx: ExtensionCommandContext,
+	agentName: string,
+	agentModels: Readonly<Record<string, string>>,
+	escNote = "cancels this setup pass",
+): Promise<string | undefined> {
+	const profile = agentProfile(agentName);
+	const duty = profile ? ` — ${profile.summary}` : "";
+	return pickConfiguredModel(
+		ctx,
+		`Model for ${agentName}${duty}?`,
+		agentModels[agentName],
+		escNote,
+	);
+}
+
+function effectiveModelForChoice(
+	ctx: ExtensionCommandContext,
+	agentName: string,
+	choice: string,
+	agentModels: Readonly<Record<string, string>>,
+): Model<Api> | undefined {
+	const selectedModels = applyAgentModelChoice({ ...agentModels }, agentName, choice);
+	const ref = selectedModels[agentName];
+	return findModelByRef(availableModelsInScope(ctx), ref) ?? ctx.model;
+}
+
+/** The role default is marked; picking it clears a stored override. */
+async function pickAgentStrength(
+	ctx: ExtensionCommandContext,
+	agentName: string,
+	model: Model<Api> | undefined,
+	current: ThinkingLevel | undefined,
+	escNote = "cancels this setup pass",
+): Promise<ThinkingLevel | undefined> {
+	const supported = supportedThinkingLevels(model);
+	const roleDefault = resolveThinkingLevel(model, roleThinkingLevel(agentName));
+	if (supported.length <= 1) return roleDefault;
+
+	const currentEffective = current ? resolveThinkingLevel(model, current) : roleDefault;
+	const modelName = model ? modelRef(model) : "current main model";
+	const options = supported.map((level) => {
+		const tags = [
+			level === roleDefault ? "role default" : "",
+			current !== undefined && currentEffective === level ? "current" : "",
+		].filter(Boolean);
+		return {
+			value: level,
+			label: `${level} — ${THINKING_LEVEL_HINTS[level]}${tags.length ? ` (${tags.join(", ")})` : ""}`,
+		};
+	});
+	return promptSelectOne(
+		ctx,
+		`Thinking for ${agentName}?`,
+		`${agentName} defaults to ${roleDefault} on ${modelName} • Enter selects • Esc ${escNote}`,
+		options,
+		currentEffective,
+	) as Promise<ThinkingLevel | undefined>;
+}
+
+async function pickAgentToConfigure(
+	ctx: ExtensionCommandContext,
+	enabledAgents: readonly string[],
+): Promise<string | undefined> {
+	if (enabledAgents.length === 0) {
+		ctx.ui.notify("No agents are enabled. Enable agents first.", "warning");
+		return undefined;
+	}
+	return promptSelectOne(
+		ctx,
+		"Configure which agent?",
+		"Name, then what it owns • ↑/↓ • Enter selects • Esc returns to settings",
+		enabledAgents.map((name) => {
+			const profile = agentProfile(name);
+			return {
+				value: name,
+				label: moduleLabel(name),
+				description: profile?.remark,
+			};
+		}),
+	);
+}
+
+interface ConfiguredAgentChoice {
+	name: string;
+	model: string;
+	strength: ThinkingLevel;
+}
+
+async function configureOneAgent(
+	ctx: ExtensionCommandContext,
+	config: SubagentsConfig,
+): Promise<ConfiguredAgentChoice | undefined> {
+	while (true) {
+		const name = await pickAgentToConfigure(ctx, config.enabledAgents);
+		if (name === undefined) return undefined;
+		const profile = agentProfile(name);
+		if (profile) ctx.ui.notify(`${name}: ${profile.remark}`, "info");
+
+		while (true) {
+			const modelChoice = await pickAgentModel(
+				ctx,
+				name,
+				config.agentModels,
+				"returns to agent selection",
+			);
+			if (modelChoice === undefined) break;
+			const model = effectiveModelForChoice(ctx, name, modelChoice, config.agentModels);
+			const strength = await pickAgentStrength(
+				ctx,
+				name,
+				model,
+				config.agentThinkingLevels[name],
+				"returns to model selection",
+			);
+			if (strength === undefined) continue;
+			return { name, model: modelChoice, strength };
+		}
+	}
+}
+
+function keepAgentEntries<T>(record: Record<string, T>, enabled: readonly string[]): Record<string, T> {
+	const keep = new Set(enabled);
+	return Object.fromEntries(Object.entries(record).filter(([name]) => keep.has(name)));
+}
+
+function applyThinkingChoice(
+	levels: Record<string, ThinkingLevel>,
+	agentName: string,
+	strength: ThinkingLevel,
+	model: Model<Api> | undefined,
+): Record<string, ThinkingLevel> {
+	const next = { ...levels };
+	const roleDefault = resolveThinkingLevel(model, roleThinkingLevel(agentName));
+	if (strength === roleDefault) delete next[agentName];
+	else next[agentName] = resolveThinkingLevel(model, strength);
+	return next;
+}
+
+async function introduceSetup(ctx: ExtensionCommandContext): Promise<boolean> {
+	const lines = BUILTIN_AGENT_NAMES.map((name) => {
+		const profile = AGENT_PROFILES[name];
+		return `${name} — ${profile.summary}. ${profile.remark}`;
+	});
+	const defaults = BUILTIN_AGENT_NAMES.map((name) => `${name} ${roleThinkingLevel(name)}`).join(", ");
+	ctx.ui.notify(
+		`pi-subagents: ${lines.join(" ")} Pick a model for each role next. Thinking defaults per role (${defaults}); change it on a role when you want.`,
+		"info",
+	);
+	const choice = await ctx.ui.select("How to configure pi-subagents", [
+		"Continue — pick a model for each role (thinking has a role default you can change later)",
+	]);
+	return choice !== undefined;
+}
+
+async function runFullSetup(ctx: ExtensionCommandContext, configPath: string, base: SubagentsConfig): Promise<boolean> {
+	if (!(await introduceSetup(ctx))) return false;
+
+	const enabled = await pickEnabledAgents(ctx, base);
+	if (enabled === undefined) return false;
+
+	let agentModels = keepAgentEntries(base.agentModels, enabled);
+	for (const agentName of enabled) {
+		const profile = agentProfile(agentName);
+		if (profile) ctx.ui.notify(`${agentName}: ${profile.remark}`, "info");
+		const choice = await pickAgentModel(ctx, agentName, agentModels);
+		if (choice === undefined) return false;
+		agentModels = applyAgentModelChoice(agentModels, agentName, choice);
+	}
+
+	const next: SubagentsConfig = {
+		enabledAgents: enabled,
+		knownAgents: setupAgentNames(base),
+		agentModels,
+		agentThinkingLevels: keepAgentEntries(base.agentThinkingLevels, enabled),
+		maxResultLines: base.maxResultLines,
+		agentScope: base.agentScope,
+		idleTimeoutSec: base.idleTimeoutSec,
+	};
+	await saveConfig(next, configPath);
+	ctx.ui.notify(
+		`pi-subagents saved to ${configPath}. Role thinking defaults apply; open Configure an agent to change one.`,
+		"info",
+	);
+	return true;
+}
+
+async function runMenu(ctx: ExtensionCommandContext, configPath: string, config: SubagentsConfig): Promise<void> {
+	while (true) {
+		const choice = await ctx.ui.select("pi-subagents settings", [
+			"Enable/disable agents — choose which roles are available",
+			"Configure an agent — model and thinking, with its job on the row",
+			"Full re-setup — walk through the team and pick models again",
+		]);
+		if (choice === undefined) return;
+		if (choice.startsWith("Full")) {
+			if (await runFullSetup(ctx, configPath, config)) return;
+			continue;
+		}
+
+		let next: SubagentsConfig = {
+			...config,
+			agentModels: { ...config.agentModels },
+			agentThinkingLevels: { ...config.agentThinkingLevels },
+		};
+		if (choice.startsWith("Enable")) {
+			const enabled = await pickEnabledAgents(ctx, config);
+			if (enabled === undefined) continue;
+			next.enabledAgents = enabled;
+			next.agentModels = keepAgentEntries(next.agentModels, enabled);
+			next.agentThinkingLevels = keepAgentEntries(next.agentThinkingLevels, enabled);
+		} else {
+			let configuredAny = false;
+			while (true) {
+				const picked = await configureOneAgent(ctx, next);
+				if (!picked) break;
+				configuredAny = true;
+				next.agentModels = applyAgentModelChoice(next.agentModels, picked.name, picked.model);
+				const model = effectiveModelForChoice(ctx, picked.name, picked.model, next.agentModels);
+				next.agentThinkingLevels = applyThinkingChoice(
+					next.agentThinkingLevels,
+					picked.name,
+					picked.strength,
+					model,
+				);
+			}
+			if (!configuredAny) continue;
+			await saveConfig(next, configPath);
+			ctx.ui.notify(`pi-subagents updated. Saved to ${configPath}`, "info");
+			config = next;
+			continue;
+		}
+
+		await saveConfig(next, configPath);
+		ctx.ui.notify(`pi-subagents updated. Saved to ${configPath}`, "info");
+		return;
+	}
+}
+
+/** Entry point for the /subagents-setup command. */
+export async function runSetup(ctx: ExtensionCommandContext, configPath: string = getConfigPath()): Promise<void> {
+	if (ctx.mode !== "tui") {
+		ctx.ui.notify("/subagents-setup requires Pi's interactive TUI.", "error");
+		return;
+	}
+	try {
+		const exists = await configExists(configPath);
+		const config = await loadConfig(configPath);
+		if (exists) await runMenu(ctx, configPath, config);
+		else if (!(await runFullSetup(ctx, configPath, { ...DEFAULT_CONFIG, enabledAgents: [...DEFAULT_ENABLED_AGENTS] }))) {
+			ctx.ui.notify("pi-subagents setup cancelled.", "info");
+		}
+	} catch (error) {
+		ctx.ui.notify(`pi-subagents setup failed: ${errorMessage(error)}`, "error");
+	}
+}

package/src/configuration/ui.ts

@@ -0,0 +1,245 @@
+/**
+ * TUI pickers for /subagents-setup, built on @earendil-works/pi-tui.
+ *
+ * A single self-contained `Picker` component powers both selectors:
+ *   - single-select (model picker): type to fuzzy-filter, arrows to move,
+ *     PageUp/PageDown to page, Enter to choose, Esc to cancel.
+ *   - multi-select (module picker): same navigation, Space toggles a checkbox,
+ *     Enter confirms the selection set.
+ *
+ * pi-tui's built-in SelectList only handles up/down/confirm/cancel (no paging),
+ * so we render the list ourselves and use the injected keybinding manager. Every line
+ * is passed through truncateToWidth() — pi hard-crashes if a rendered line is
+ * wider than the terminal.
+ */
+
+import {
+	fuzzyFilter,
+	truncateToWidth,
+	type Component,
+	type Focusable,
+	type KeybindingsManager,
+	type SelectItem,
+	type TUI,
+} from "@earendil-works/pi-tui";
+import type { ExtensionCommandContext, Theme } from "@earendil-works/pi-coding-agent";
+
+/** The slice of the extension context the pickers need (mode + ui). */
+type PickerContext = Pick<ExtensionCommandContext, "mode" | "ui">;
+
+/** Rows shown at once; longer lists are reached with PageUp/PageDown. */
+const PAGE_SIZE = 8;
+
+interface PickerStyles {
+	border: (t: string) => string;
+	title: (t: string) => string;
+	hint: (t: string) => string;
+	cursorMark: (t: string) => string;
+	selectedLabel: (t: string) => string;
+	label: (t: string) => string;
+	dim: (t: string) => string;
+	checked: (t: string) => string;
+	unchecked: (t: string) => string;
+	filterEcho: (t: string) => string;
+}
+
+type PickerItem = SelectItem;
+
+function pickerItemSearchText(item: PickerItem): string {
+	return `${item.value} ${item.label} ${item.description ?? ""}`;
+}
+
+interface PickerCallbacks {
+	/** single-select: fired with the highlighted value on Enter. */
+	onSelect?: (value: string) => void;
+	/** multi-select: fired with the full chosen set on Enter. */
+	onConfirm?: (values: string[]) => void;
+	onCancel: () => void;
+}
+
+class Picker implements Component, Focusable {
+	private _focused = false;
+	private query = "";
+	private cursor = 0;
+	private filtered: PickerItem[];
+
+	constructor(
+		private readonly items: PickerItem[],
+		private readonly multi: boolean,
+		private readonly selected: Set<string>,
+		private readonly styles: PickerStyles,
+		private readonly headerLines: string[],
+		private readonly tui: TUI,
+		private readonly keybindings: KeybindingsManager,
+		private readonly cb: PickerCallbacks,
+		initialValue?: string,
+	) {
+		this.filtered = items;
+		const initialIndex = initialValue === undefined ? -1 : items.findIndex((item) => item.value === initialValue);
+		if (initialIndex >= 0) this.cursor = initialIndex;
+	}
+
+	get focused(): boolean {
+		return this._focused;
+	}
+	set focused(value: boolean) {
+		this._focused = value;
+	}
+
+	private recompute(): void {
+		const q = this.query.trim();
+		this.filtered = q ? fuzzyFilter(this.items, q, pickerItemSearchText) : this.items;
+		this.cursor = Math.max(0, Math.min(this.cursor, this.filtered.length - 1));
+	}
+
+	render(width: number): string[] {
+		const s = this.styles;
+		const fit = (line: string): string => truncateToWidth(line, width, "");
+		const border = fit(s.border("─".repeat(Math.max(1, width))));
+
+		const lines: string[] = [border];
+		for (const h of this.headerLines) lines.push(fit(h));
+		lines.push(fit(this.query ? s.filterEcho(`filter: ${this.query}`) : s.dim("filter: (type to narrow)")));
+		lines.push(border);
+
+		if (this.filtered.length === 0) {
+			lines.push(fit(s.dim("  (no matches)")));
+		} else {
+			const start = Math.max(
+				0,
+				Math.min(this.cursor - Math.floor(PAGE_SIZE / 2), this.filtered.length - PAGE_SIZE),
+			);
+			const visible = this.filtered.slice(start, start + PAGE_SIZE);
+			for (let i = 0; i < visible.length; i++) {
+				const item = visible[i];
+				const isCursor = start + i === this.cursor;
+				const mark = isCursor ? s.cursorMark("❯ ") : "  ";
+				const label = isCursor ? s.selectedLabel(item.label) : s.label(item.label);
+				const description = item.description ? s.dim(` — ${item.description}`) : "";
+				const line = this.multi
+					? mark + (this.selected.has(item.value) ? s.checked("[x] ") : s.unchecked("[ ] ")) + label + description
+					: mark + label + description;
+				lines.push(fit(line));
+			}
+			const more = this.filtered.length > PAGE_SIZE ? "  ↑/↓ move • PgUp/PgDn page" : "";
+			lines.push(fit(s.dim(`  (${this.cursor + 1}/${this.filtered.length})${more}`)));
+		}
+
+		lines.push(border);
+		return lines;
+	}
+
+	handleInput(data: string): void {
+		const kb = this.keybindings;
+		if (kb.matches(data, "tui.select.up")) {
+			if (this.filtered.length > 0) this.cursor = this.cursor === 0 ? this.filtered.length - 1 : this.cursor - 1;
+		} else if (kb.matches(data, "tui.select.down")) {
+			if (this.filtered.length > 0) this.cursor = this.cursor === this.filtered.length - 1 ? 0 : this.cursor + 1;
+		} else if (kb.matches(data, "tui.select.pageUp")) {
+			this.cursor = Math.max(0, this.cursor - PAGE_SIZE);
+		} else if (kb.matches(data, "tui.select.pageDown")) {
+			this.cursor = Math.min(Math.max(0, this.filtered.length - 1), this.cursor + PAGE_SIZE);
+		} else if (kb.matches(data, "tui.select.confirm")) {
+			if (this.multi) this.cb.onConfirm?.([...this.selected]);
+			else {
+				const item = this.filtered[this.cursor];
+				if (item) this.cb.onSelect?.(item.value);
+			}
+			return;
+		} else if (kb.matches(data, "tui.select.cancel")) {
+			this.cb.onCancel();
+			return;
+		} else if (data === "\x7f" || data === "\b") {
+			this.query = this.query.slice(0, -1);
+			this.cursor = 0;
+			this.recompute();
+		} else if (data === " ") {
+			if (this.multi) {
+				const item = this.filtered[this.cursor];
+				if (item) {
+					if (this.selected.has(item.value)) this.selected.delete(item.value);
+					else this.selected.add(item.value);
+				}
+			} else {
+				this.query += data;
+				this.cursor = 0;
+				this.recompute();
+			}
+		} else if (isPrintable(data)) {
+			this.query += data;
+			this.cursor = 0;
+			this.recompute();
+		}
+		this.tui.requestRender();
+	}
+
+	invalidate(): void {}
+}
+
+function isPrintable(data: string): boolean {
+	if (data.length === 0) return false;
+	// Reject ESC-led escape sequences and other control characters.
+	return data.charCodeAt(0) >= 0x20;
+}
+
+/** Build style functions from the pi theme. */
+function makeStyles(theme: Theme): PickerStyles {
+	return {
+		border: (t) => theme.fg("accent", t),
+		title: (t) => theme.fg("accent", theme.bold(t)),
+		hint: (t) => theme.fg("dim", t),
+		cursorMark: (t) => theme.fg("accent", t),
+		selectedLabel: (t) => theme.fg("accent", theme.bold(t)),
+		label: (t) => t,
+		dim: (t) => theme.fg("dim", t),
+		checked: (t) => theme.fg("accent", t),
+		unchecked: (t) => theme.fg("dim", t),
+		filterEcho: (t) => theme.fg("accent", t),
+	};
+}
+
+function requireTui(ctx: PickerContext): boolean {
+	if (ctx.mode !== "tui") {
+		ctx.ui.notify("/subagents-setup requires Pi's interactive TUI.", "error");
+		return false;
+	}
+	return true;
+}
+
+/** Single-select with fuzzy filter + paging. Resolves undefined on Esc. */
+export function promptSelectOne(
+	ctx: PickerContext,
+	title: string,
+	hint: string,
+	items: PickerItem[],
+	initialValue?: string,
+): Promise<string | undefined> {
+	if (!requireTui(ctx)) return Promise.resolve(undefined);
+	return ctx.ui.custom<string | undefined>((tui, theme, keybindings, done) => {
+		const styles = makeStyles(theme);
+		const header = [styles.title(title), styles.hint(hint)];
+		return new Picker(items, false, new Set<string>(), styles, header, tui, keybindings, {
+			onSelect: (value) => done(value),
+			onCancel: () => done(undefined),
+		}, initialValue);
+	});
+}
+
+/** Multi-select with fuzzy filter + paging. Resolves undefined on Esc. */
+export function promptSelectMany(
+	ctx: PickerContext,
+	title: string,
+	hint: string,
+	items: PickerItem[],
+	initialSelected: readonly string[],
+): Promise<string[] | undefined> {
+	if (!requireTui(ctx)) return Promise.resolve(undefined);
+	return ctx.ui.custom<string[] | undefined>((tui, theme, keybindings, done) => {
+		const styles = makeStyles(theme);
+		const header = [styles.title(title), styles.hint(hint)];
+		return new Picker(items, true, new Set<string>(initialSelected), styles, header, tui, keybindings, {
+			onConfirm: (values) => done(values),
+			onCancel: () => done(undefined),
+		});
+	});
+}

package/src/{agents.ts → delegation/agents.ts}

@@ -15,8 +15,8 @@ import { type Dirent, existsSync, readdirSync, readFileSync, statSync } from "no
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { CONFIG_DIR_NAME, getAgentDir, parseFrontmatter } from "@earendil-works/pi-coding-agent";
-import { type AgentScope } from "./config.ts";
-import type { IsolationMode } from "./worktree.ts";
+import { type AgentScope } from "../configuration/config.ts";
+import type { IsolationMode } from "../isolation/worktree.ts";
 
 export type AgentSource = "builtin" | "user" | "project";
 
@@ -113,7 +113,7 @@ export function isWriteCapableAgent(
 
 const here = dirname(fileURLToPath(import.meta.url));
 /** <package>/agents — the agents shipped with this extension. */
-export const BUILTIN_AGENTS_DIR = join(here, "..", "agents");
+export const BUILTIN_AGENTS_DIR = join(here, "..", "..", "agents");
 
 /** Agents shipped with the package and surfaced by the setup overlay. */
 export function loadBuiltinAgents(): AgentConfig[] {

package/src/{dispatch.ts → delegation/dispatch.ts}

@@ -1,6 +1,6 @@
 /**
- * The `subagent` tool: dispatches enabled scout, artisan, steward, sentinel,
- * and custom roles as isolated pi child processes, single or parallel.
+ * The `subagent` tool: dispatches enabled built-in and custom roles as
+ * isolated pi child processes, single or parallel.
  * Owns the public dispatch contract and
  * per-run status tracking. Stable thread generations, final integration, and
  * completion ownership live in thread-lifecycle.ts.
@@ -9,11 +9,10 @@
 import { StringEnum, type Usage } from "@earendil-works/pi-ai";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { Text } from "@earendil-works/pi-tui";
-import { join, resolve } from "node:path";
 import { Type } from "typebox";
-import { discoverAgents, resolveAgentTools, type AgentConfig } from "./agents.ts";
-import { loadConfig } from "./config.ts";
-import { formatCompletionBlock, formatUsage, queuedResult } from "./format.ts";
+import { discoverAgents } from "./agents.ts";
+import { loadConfig } from "../configuration/config.ts";
+import { formatCompletionBlock, formatUsage } from "../presentation/format.ts";
 import {
 	formatTaskSummary,
 	formatToolActivity,
@@ -21,32 +20,27 @@ import {
 	statusIcon,
 	statusLabel,
 	sumUsage,
-	type RunView,
 	type RunWaitReason,
-} from "./monitor.ts";
+} from "../presentation/monitor.ts";
 import { formatPhaseLeaseReceipt } from "./prompt.ts";
-import type { SubagentRuntime, SubagentThread } from "./runtime.ts";
-import { persistThreadCheckpoint } from "./thread-lifecycle.ts";
+import type { SubagentRuntime, SubagentThread } from "../lifecycle/runtime.ts";
+import { createBackgroundDispatcher } from "../lifecycle/thread-lifecycle.ts";
 import {
-	getProjectRoot,
 	getResultOutput,
 	isFailedResult,
-	runSingleAgentWithMainFallback,
 	type SingleResult,
 	type SubagentDetails,
 	type SubagentLiveEvent,
 	type UsageStats,
-} from "./spawn.ts";
+} from "../execution/spawn.ts";
 import {
-	createBackgroundDispatcher,
 	isWorktreeCapableAgent,
+	persistThreadCheckpoint,
 	projectResultsRoot,
-	resolveDispatchModelRoute,
 	runInManagedRepositoryLane,
-	withWorktreeSystemPrompt,
 	type DispatchEnvironment,
-} from "./thread-lifecycle.ts";
-import type { IsolationMode } from "./worktree.ts";
+} from "../lifecycle/thread-shared.ts";
+import type { IsolationMode } from "../isolation/worktree.ts";
 
 export { isWorktreeCapableAgent, runInManagedRepositoryLane };