@duckmind/dm-darwin-arm64 0.12.4 → 0.13.2

package/extensions/dm-subagents/agent-manager.ts

@@ -0,0 +1,405 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import type { Theme } from "@mariozechner/pi-coding-agent";
+import type { Component, TUI } from "@mariozechner/pi-tui";
+import { matchesKey, truncateToWidth, visibleWidth } from "@mariozechner/pi-tui";
+import type { AgentConfig, ChainConfig } from "./agents.ts";
+import { serializeAgent } from "./agent-serializer.ts";
+import { TEMPLATE_ITEMS, type AgentTemplate, type TemplateItem } from "./agent-templates.ts";
+import { parseChain, serializeChain } from "./chain-serializer.ts";
+import { renderList, handleListInput, type ListAgent, type ListState, type ListAction } from "./agent-manager-list.ts";
+import { createParallelState, handleParallelInput, renderParallel, formatParallelTitle, type ParallelState, type AgentOption } from "./agent-manager-parallel.ts";
+import { renderDetail, handleDetailInput, renderTaskInput, type DetailState, type DetailAction } from "./agent-manager-detail.ts";
+import { renderChainDetail, handleChainDetailInput, type ChainDetailAction, type ChainDetailState } from "./agent-manager-chain-detail.ts";
+import { createEditState, handleEditInput, renderEdit, type EditScreen, type EditState, type ModelInfo, type SkillInfo } from "./agent-manager-edit.ts";
+import { createEditorState, ensureCursorVisible, getCursorDisplayPos, handleEditorInput, renderEditor, wrapText } from "./text-editor.ts";
+import type { TextEditorState } from "./text-editor.ts";
+import { loadRunsForAgent } from "./run-history.ts";
+import { pad, row, renderHeader, renderFooter } from "./render-helpers.ts";
+
+export type ManagerResult =
+	| { action: "launch"; agent: string; task: string; skipClarify?: boolean }
+	| { action: "chain"; agents: string[]; task: string; skipClarify?: boolean }
+	| { action: "parallel"; tasks: Array<{ agent: string; task: string }>; skipClarify?: boolean }
+	| { action: "launch-chain"; chain: ChainConfig; task: string; skipClarify?: boolean }
+	| undefined;
+
+export interface AgentData { builtin: AgentConfig[]; user: AgentConfig[]; project: AgentConfig[]; chains: ChainConfig[]; userDir: string; projectDir: string | null; cwd: string; }
+type ManagerScreen = "list" | "detail" | "chain-detail" | "edit" | "edit-field" | "edit-prompt" | "task-input" | "confirm-delete" | "name-input" | "chain-edit" | "template-select" | "parallel-builder";
+interface AgentEntry { id: string; kind: "agent"; config: AgentConfig; isNew: boolean; }
+interface ChainEntry { id: string; kind: "chain"; config: ChainConfig; }
+interface NameInputState { mode: "new-agent" | "clone-agent" | "clone-chain" | "new-chain"; editor: TextEditorState; scope: "user" | "project"; allowProject: boolean; sourceId?: string; template?: AgentTemplate; error?: string; }
+interface StatusMessage { text: string; type: "error" | "info"; }
+
+function cloneConfig(config: AgentConfig): AgentConfig { return { ...config, tools: config.tools ? [...config.tools] : undefined, mcpDirectTools: config.mcpDirectTools ? [...config.mcpDirectTools] : undefined, skills: config.skills ? [...config.skills] : undefined, defaultReads: config.defaultReads ? [...config.defaultReads] : undefined, extraFields: config.extraFields ? { ...config.extraFields } : undefined }; }
+function cloneChainConfig(config: ChainConfig): ChainConfig { return { ...config, steps: config.steps.map((step) => ({ ...step, reads: Array.isArray(step.reads) ? [...step.reads] : step.reads, skills: Array.isArray(step.skills) ? [...step.skills] : step.skills })), extraFields: config.extraFields ? { ...config.extraFields } : undefined }; }
+function slugTemplateName(name: string): string { return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, ""); }
+function nextSelectableIndex(items: TemplateItem[], current: number, direction: 1 | -1): number { let next = current + direction; while (next >= 0 && next < items.length && items[next]!.type === "separator") next += direction; if (next < 0 || next >= items.length) return current; return next; }
+const CHAIN_EDIT_VIEWPORT = 10;
+
+export class AgentManagerComponent implements Component {
+	private overlayWidth = 84;
+	private screen: ManagerScreen = "list";
+	private agents: AgentEntry[] = [];
+	private chains: ChainEntry[] = [];
+	private listState: ListState = { cursor: 0, scrollOffset: 0, filterQuery: "", selected: [] };
+	private detailState: DetailState = { resolved: true, scrollOffset: 0 };
+	private chainDetailState: ChainDetailState = { scrollOffset: 0 };
+	private editState: EditState | null = null;
+	private currentAgentId: string | null = null;
+	private currentChainId: string | null = null;
+	private confirmDeleteId: string | null = null;
+	private nameInputState: NameInputState | null = null;
+	private chainEditState: { editor: TextEditorState; error?: string } | null = null;
+	private taskEditor: TextEditorState = createEditorState();
+	private skipClarify = false;
+	private chainAgentIds: string[] = [];
+	private chainLaunchId: string | null = null;
+	private parallelMode = false;
+	private parallelState: ParallelState | null = null;
+	private taskBackScreen: ManagerScreen = "list";
+	private templateCursor = 0;
+	private statusMessage?: StatusMessage;
+	private nextId = 1;
+	private tui: TUI;
+	private theme: Theme;
+	private agentData: AgentData;
+	private models: ModelInfo[];
+	private skills: SkillInfo[];
+	private done: (result: ManagerResult) => void;
+
+	constructor(tui: TUI, theme: Theme, agentData: AgentData, models: ModelInfo[], skills: SkillInfo[], done: (result: ManagerResult) => void) {
+		this.tui = tui;
+		this.theme = theme;
+		this.agentData = agentData;
+		this.models = models;
+		this.skills = skills;
+		this.done = done;
+		this.loadEntries();
+	}
+
+	private loadEntries(): void {
+		const overridden = new Set([...this.agentData.user, ...this.agentData.project].map((c) => c.name));
+		const agents: AgentEntry[] = []; for (const config of this.agentData.builtin) { if (!overridden.has(config.name)) agents.push({ id: `a${this.nextId++}`, kind: "agent", config: cloneConfig(config), isNew: false }); } for (const config of this.agentData.user) agents.push({ id: `a${this.nextId++}`, kind: "agent", config: cloneConfig(config), isNew: false }); for (const config of this.agentData.project) agents.push({ id: `a${this.nextId++}`, kind: "agent", config: cloneConfig(config), isNew: false }); this.agents = agents;
+		const chains: ChainEntry[] = []; for (const config of this.agentData.chains) chains.push({ id: `c${this.nextId++}`, kind: "chain", config: cloneChainConfig(config) }); this.chains = chains;
+	}
+
+	private getAgentEntry(id: string | null): AgentEntry | undefined { if (!id) return undefined; return this.agents.find((entry) => entry.id === id); }
+	private getChainEntry(id: string | null): ChainEntry | undefined { if (!id) return undefined; return this.chains.find((entry) => entry.id === id); }
+	private listAgents(): ListAgent[] { const a = this.agents.map((entry) => ({ id: entry.id, name: entry.config.name, description: entry.config.description, model: entry.config.model, source: entry.config.source, kind: "agent" as const })); const c = this.chains.map((entry) => ({ id: entry.id, name: entry.config.name, description: entry.config.description, source: entry.config.source, kind: "chain" as const, stepCount: entry.config.steps.length })); return [...a, ...c]; }
+	private clearStatus(): void { this.statusMessage = undefined; }
+
+	private removeAgentEntry(entry: AgentEntry): void { this.agents = this.agents.filter((e) => e.id !== entry.id); this.listState.selected = this.listState.selected.filter((id) => id !== entry.id); }
+	private removeChainEntry(entry: ChainEntry): void { this.chains = this.chains.filter((e) => e.id !== entry.id); }
+
+	private enterDetail(entry: AgentEntry): void { this.currentAgentId = entry.id; this.detailState = { resolved: true, scrollOffset: 0, recentRuns: loadRunsForAgent(entry.config.name).slice(0, 5) }; this.screen = "detail"; }
+	private enterChainDetail(entry: ChainEntry): void { this.currentChainId = entry.id; this.chainDetailState = { scrollOffset: 0 }; this.screen = "chain-detail"; }
+	private enterEdit(entry: AgentEntry): void { this.currentAgentId = entry.id; this.editState = createEditState(entry.config, entry.isNew, this.models, this.skills); this.screen = "edit"; }
+	private enterParallelBuilder(ids: string[]): void {
+		const names = ids.map((id) => this.getAgentEntry(id)?.config.name).filter((n): n is string => Boolean(n));
+		if (names.length === 0) return;
+		this.parallelState = createParallelState(names);
+		this.screen = "parallel-builder";
+	}
+	private enterTaskInput(ids: string[], backScreen: ManagerScreen = "list"): void {
+		if (ids.length > 1) {
+			const names = ids.map((id) => { const e = this.getAgentEntry(id); return e ? e.config.name : id; });
+			this.done({ action: "chain", agents: names, task: "", skipClarify: false });
+			return;
+		}
+		this.chainAgentIds = ids; this.chainLaunchId = null; this.parallelMode = false; this.taskBackScreen = backScreen; this.taskEditor = createEditorState(); this.skipClarify = true; this.screen = "task-input";
+	}
+	private enterSavedChainLaunch(entry: ChainEntry): void { this.chainLaunchId = entry.id; this.chainAgentIds = []; this.parallelMode = false; this.taskBackScreen = "chain-detail"; this.taskEditor = createEditorState(); this.skipClarify = true; this.screen = "task-input"; }
+	private enterTemplateSelect(): void { this.templateCursor = TEMPLATE_ITEMS.findIndex((item) => item.type !== "separator"); if (this.templateCursor < 0) this.templateCursor = 0; this.screen = "template-select"; }
+
+	private enterChainEdit(entry: ChainEntry): void {
+		try { const content = fs.readFileSync(entry.config.filePath, "utf-8"); this.currentChainId = entry.id; this.chainEditState = { editor: createEditorState(content) }; this.screen = "chain-edit"; }
+		catch (err) { this.statusMessage = { text: err instanceof Error ? err.message : "Failed to load chain file.", type: "error" }; this.screen = "list"; }
+	}
+
+	private enterNameInput(mode: NameInputState["mode"], sourceId?: string, template?: AgentTemplate): void {
+		const allowProject = Boolean(this.agentData.projectDir); let initial = ""; let scope: "user" | "project" = "user";
+		if (mode === "clone-agent" && sourceId) { const entry = this.getAgentEntry(sourceId); if (entry) { initial = `${entry.config.name}-copy`; scope = entry.config.source === "project" ? "project" : "user"; } }
+		if (mode === "clone-chain" && sourceId) { const entry = this.getChainEntry(sourceId); if (entry) { initial = `${entry.config.name}-copy`; scope = entry.config.source === "project" ? "project" : "user"; } }
+		if (mode === "new-agent" && template && template.name !== "Blank") initial = slugTemplateName(template.name);
+		this.nameInputState = { mode, editor: createEditorState(initial), scope, allowProject, sourceId, template }; this.screen = "name-input";
+	}
+
+	private saveEdit(): boolean {
+		const edit = this.editState; if (!edit) return false; const entry = this.getAgentEntry(this.currentAgentId); if (!entry) return false;
+		if (!edit.draft.name || !edit.draft.description) { edit.error = "Name and description are required."; return false; }
+		let filePath = entry.config.filePath;
+		if (entry.isNew) {
+			const dir = edit.draft.source === "project" ? this.agentData.projectDir : this.agentData.userDir;
+			if (!dir) { edit.error = "Project agents directory not found."; return false; }
+			filePath = path.join(dir, `${edit.draft.name}.md`);
+			if (fs.existsSync(filePath)) { edit.error = "An agent with that name already exists."; return false; }
+			fs.mkdirSync(dir, { recursive: true });
+		}
+		try { const toSave: AgentConfig = { ...edit.draft, filePath }; fs.writeFileSync(filePath, serializeAgent(toSave), "utf-8"); entry.config = cloneConfig(toSave); entry.isNew = false; edit.error = undefined; return true; }
+		catch (err) { edit.error = err instanceof Error ? err.message : "Failed to save agent."; return false; }
+	}
+
+	private saveChainEdit(): boolean {
+		const state = this.chainEditState; const entry = this.getChainEntry(this.currentChainId); if (!state || !entry) return false;
+		try { const parsed = parseChain(state.editor.buffer, entry.config.source, entry.config.filePath); fs.writeFileSync(entry.config.filePath, serializeChain(parsed), "utf-8"); entry.config = parsed; state.error = undefined; return true; }
+		catch (err) { state.error = err instanceof Error ? err.message : "Failed to save chain."; return false; }
+	}
+
+	private handleTemplateSelectInput(data: string): void {
+		if (matchesKey(data, "escape") || matchesKey(data, "ctrl+c")) { this.screen = "list"; this.tui.requestRender(); return; }
+		if (matchesKey(data, "up")) { this.templateCursor = nextSelectableIndex(TEMPLATE_ITEMS, this.templateCursor, -1); this.tui.requestRender(); return; }
+		if (matchesKey(data, "down")) { this.templateCursor = nextSelectableIndex(TEMPLATE_ITEMS, this.templateCursor, 1); this.tui.requestRender(); return; }
+		if (matchesKey(data, "return")) {
+			const item = TEMPLATE_ITEMS[this.templateCursor];
+			if (!item || item.type === "separator") return;
+			if (item.type === "agent") this.enterNameInput("new-agent", undefined, { name: item.name, config: item.config });
+			else if (item.type === "chain") this.enterNameInput("new-chain");
+			this.tui.requestRender();
+		}
+	}
+
+	private handleNameInput(data: string): void {
+		const state = this.nameInputState; if (!state) return; state.error = undefined;
+		const canToggleScope = state.allowProject;
+		if (matchesKey(data, "tab")) { if (canToggleScope) { state.scope = state.scope === "user" ? "project" : "user"; this.tui.requestRender(); } return; }
+		const innerW = this.overlayWidth - 2; const boxInnerWidth = Math.max(10, innerW - 4);
+		const nextState = handleEditorInput(state.editor, data, boxInnerWidth); if (nextState) { state.editor = nextState; this.tui.requestRender(); return; }
+		if (matchesKey(data, "escape") || matchesKey(data, "ctrl+c")) { this.nameInputState = null; this.screen = "list"; this.tui.requestRender(); return; }
+		if (!matchesKey(data, "return")) return;
+		const name = state.editor.buffer.trim(); if (!name) { state.error = "Name is required."; this.tui.requestRender(); return; }
+
+		if (state.mode === "clone-chain" && state.sourceId) {
+			const sourceEntry = this.getChainEntry(state.sourceId); if (!sourceEntry) { this.screen = "list"; this.tui.requestRender(); return; }
+			const dir = state.scope === "project" ? this.agentData.projectDir : this.agentData.userDir;
+			if (!dir) { state.error = "Project agents directory not found."; this.tui.requestRender(); return; }
+			const filePath = path.join(dir, `${name}.chain.md`); if (fs.existsSync(filePath)) { state.error = "A chain with that name already exists."; this.tui.requestRender(); return; }
+			try { const cloned = cloneChainConfig({ ...sourceEntry.config, name, source: state.scope, filePath }); fs.mkdirSync(dir, { recursive: true }); fs.writeFileSync(filePath, serializeChain(cloned), "utf-8"); const added: ChainEntry = { id: `c${this.nextId++}`, kind: "chain", config: cloned }; this.chains.push(added); this.nameInputState = null; this.enterChainDetail(added); this.tui.requestRender(); return; }
+			catch (err) { state.error = err instanceof Error ? err.message : "Failed to clone chain."; this.tui.requestRender(); return; }
+		}
+		if (state.mode === "new-chain") {
+			const dir = state.scope === "project" ? this.agentData.projectDir : this.agentData.userDir;
+			if (!dir) { state.error = "Directory not found."; this.tui.requestRender(); return; }
+			const filePath = path.join(dir, `${name}.chain.md`); if (fs.existsSync(filePath)) { state.error = "A chain with that name already exists."; this.tui.requestRender(); return; }
+			const config: ChainConfig = { name, description: "Describe this chain", source: state.scope, filePath, steps: [{ agent: "agent-name", task: "{task}" }] };
+			try { fs.mkdirSync(dir, { recursive: true }); fs.writeFileSync(filePath, serializeChain(config), "utf-8"); const entry: ChainEntry = { id: `c${this.nextId++}`, kind: "chain", config }; this.chains.push(entry); this.nameInputState = null; this.enterChainEdit(entry); }
+			catch (err) { state.error = err instanceof Error ? err.message : "Failed to create chain."; }
+			this.tui.requestRender(); return;
+		}
+
+		let baseConfig: AgentConfig;
+		if (state.mode === "clone-agent" && state.sourceId) {
+			const sourceEntry = this.getAgentEntry(state.sourceId); if (!sourceEntry) { this.screen = "list"; this.tui.requestRender(); return; }
+			baseConfig = cloneConfig(sourceEntry.config);
+		} else {
+			const templateConfig = state.template?.config ?? {};
+			baseConfig = { name, description: "Describe this agent", systemPrompt: "", source: state.scope, filePath: "", ...templateConfig };
+		}
+		const dir = state.scope === "project" ? this.agentData.projectDir : this.agentData.userDir;
+		if (!dir) { state.error = "Project agents directory not found."; this.tui.requestRender(); return; }
+		const filePath = path.join(dir, `${name}.md`); const config: AgentConfig = { ...baseConfig, name, source: state.scope, filePath };
+		const entry: AgentEntry = { id: `a${this.nextId++}`, kind: "agent", config, isNew: true };
+		this.agents.push(entry); this.nameInputState = null; this.enterEdit(entry); this.tui.requestRender();
+	}
+
+	private renderNameInput(w: number): string[] {
+		const state = this.nameInputState; if (!state) return [];
+		const lines: string[] = []; const title = state.mode === "new-agent" ? "New Agent" : state.mode === "clone-agent" ? "Clone Agent" : state.mode === "new-chain" ? "New Chain" : "Clone Chain";
+		lines.push(renderHeader(` ${title} `, w, this.theme)); lines.push(row("", w, this.theme)); lines.push(row(` ${this.theme.fg("dim", "Name:")}`, w, this.theme));
+		const innerW = w - 2; const boxInnerWidth = Math.max(10, innerW - 4); const top = `┌${"─".repeat(boxInnerWidth)}┐`; const bottom = `└${"─".repeat(boxInnerWidth)}┘`;
+		lines.push(row(` ${top}`, w, this.theme));
+		const editorState = { ...state.editor }; const wrapped = wrapText(editorState.buffer, boxInnerWidth); const cursorPos = getCursorDisplayPos(editorState.cursor, wrapped.starts); editorState.viewportOffset = ensureCursorVisible(cursorPos.line, 1, editorState.viewportOffset); const editorLine = renderEditor(editorState, boxInnerWidth, 1)[0] ?? "";
+		lines.push(row(` │${pad(editorLine, boxInnerWidth)}│`, w, this.theme)); lines.push(row(` ${bottom}`, w, this.theme));
+		if (state.mode === "new-agent" && state.template) lines.push(row(` ${this.theme.fg("dim", "Template:")} ${state.template.name}`, w, this.theme));
+		else if (state.mode === "new-chain") lines.push(row(` ${this.theme.fg("dim", "Creates a .chain.md configuration file")}`, w, this.theme));
+		else lines.push(row("", w, this.theme));
+		if (state.allowProject) { const scopeLabel = state.scope === "user" ? "[user]" : "[proj]"; lines.push(row(` ${this.theme.fg("dim", "Scope:")} ${scopeLabel}  ${this.theme.fg("dim", "[tab] toggle")}`, w, this.theme)); }
+		else lines.push(row("", w, this.theme));
+		if (state.error) lines.push(row(` ${this.theme.fg("error", state.error)}`, w, this.theme)); else lines.push(row("", w, this.theme));
+		lines.push(renderFooter(" [enter] continue  [esc] cancel ", w, this.theme)); return lines;
+	}
+
+	private renderTemplateSelect(w: number): string[] {
+		const lines: string[] = []; lines.push(renderHeader(" Select Template ", w, this.theme)); lines.push(row("", w, this.theme));
+		const innerW = w - 2; const viewport = 12; const start = Math.max(0, Math.min(this.templateCursor - Math.floor(viewport / 2), Math.max(0, TEMPLATE_ITEMS.length - viewport))); const visible = TEMPLATE_ITEMS.slice(start, start + viewport);
+		for (let i = 0; i < visible.length; i++) {
+			const idx = start + i; const item = visible[i]!;
+			if (item.type === "separator") {
+				const label = `── ${item.label} `;
+				lines.push(row(` ${this.theme.fg("dim", label + "─".repeat(Math.max(0, innerW - 1 - visibleWidth(label))))}`, w, this.theme));
+			} else {
+				const isCursor = idx === this.templateCursor; const cursor = isCursor ? this.theme.fg("accent", "▸") : " ";
+				const name = isCursor ? this.theme.fg("accent", item.name) : item.name; const desc = item.type === "agent" ? (item.config.description ?? "") : item.description;
+				lines.push(row(` ${cursor} ${pad(name, 16)} ${this.theme.fg("dim", truncateToWidth(desc, Math.max(0, innerW - 24)))}`, w, this.theme));
+			}
+		}
+		for (let i = visible.length; i < viewport; i++) lines.push(row("", w, this.theme));
+		const selected = TEMPLATE_ITEMS[this.templateCursor]; const info = selected ? selected.type === "separator" ? selected.label : selected.name : "";
+		lines.push(row(` ${this.theme.fg("dim", info)}`, w, this.theme));
+		lines.push(renderFooter(" [enter] select  [esc] cancel  [↑↓] navigate ", w, this.theme)); return lines;
+	}
+
+	private renderConfirmDelete(w: number): string[] {
+		const agent = this.getAgentEntry(this.confirmDeleteId); const chain = this.getChainEntry(this.confirmDeleteId); const name = agent?.config.name ?? chain?.config.name ?? ""; const filePath = agent?.config.filePath ?? chain?.config.filePath ?? "";
+		const lines: string[] = []; lines.push(renderHeader(` Delete "${name}"? `, w, this.theme)); lines.push(row("", w, this.theme)); const label = "File: "; const maxPath = Math.max(0, w - 2 - label.length - 1); const trimmed = truncateToWidth(filePath, maxPath);
+		lines.push(row(` ${label}${trimmed}`, w, this.theme)); lines.push(row("", w, this.theme)); lines.push(row(` ${this.theme.fg("warning", "This cannot be undone.")}`, w, this.theme)); lines.push(row("", w, this.theme)); lines.push(renderFooter(" [y] confirm  [n / esc] cancel ", w, this.theme)); return lines;
+	}
+
+	private renderChainEdit(w: number): string[] {
+		const state = this.chainEditState; const entry = this.getChainEntry(this.currentChainId); if (!state || !entry) return [];
+		const lines: string[] = []; lines.push(renderHeader(` Edit Chain: ${entry.config.name} `, w, this.theme)); lines.push(row("", w, this.theme));
+		const innerW = w - 2; const boxInnerWidth = Math.max(10, innerW - 4); const top = `┌${"─".repeat(boxInnerWidth)}┐`; const bottom = `└${"─".repeat(boxInnerWidth)}┘`;
+		lines.push(row(` ${top}`, w, this.theme));
+		const editorState = { ...state.editor }; const wrapped = wrapText(editorState.buffer, boxInnerWidth); const cursorPos = getCursorDisplayPos(editorState.cursor, wrapped.starts); editorState.viewportOffset = ensureCursorVisible(cursorPos.line, CHAIN_EDIT_VIEWPORT, editorState.viewportOffset); const editorLines = renderEditor(editorState, boxInnerWidth, CHAIN_EDIT_VIEWPORT);
+		for (const line of editorLines) lines.push(row(` │${pad(line, boxInnerWidth)}│`, w, this.theme));
+		lines.push(row(` ${bottom}`, w, this.theme)); if (state.error) lines.push(row(` ${this.theme.fg("error", state.error)}`, w, this.theme)); else lines.push(row("", w, this.theme)); lines.push(renderFooter(" [ctrl+s] save  [esc] back ", w, this.theme)); return lines;
+	}
+
+	handleInput(data: string): void {
+		if (this.screen === "list" && this.statusMessage) this.clearStatus();
+		if (this.screen.startsWith("edit") && this.editState?.error) this.editState.error = undefined;
+		switch (this.screen) {
+			case "list": { const action = handleListInput(this.listState, this.listAgents(), data); if (action) this.handleListAction(action); this.tui.requestRender(); return; }
+			case "template-select": this.handleTemplateSelectInput(data); return;
+			case "detail": {
+				const entry = this.getAgentEntry(this.currentAgentId); if (!entry) { this.screen = "list"; this.tui.requestRender(); return; }
+				const action = handleDetailInput(this.detailState, data); if (action) this.handleDetailAction(action, entry); this.tui.requestRender(); return;
+			}
+			case "chain-detail": {
+				const entry = this.getChainEntry(this.currentChainId); if (!entry) { this.screen = "list"; this.tui.requestRender(); return; }
+				const action = handleChainDetailInput(this.chainDetailState, data); if (action) this.handleChainDetailAction(action, entry); this.tui.requestRender(); return;
+			}
+			case "parallel-builder": {
+				if (!this.parallelState) { this.screen = "list"; this.tui.requestRender(); return; }
+				const agentOptions: AgentOption[] = this.agents.map((e) => ({ name: e.config.name, description: e.config.description, model: e.config.model }));
+				const pAction = handleParallelInput(this.parallelState, agentOptions, data, this.overlayWidth);
+				if (pAction?.type === "proceed") {
+					this.chainAgentIds = [];
+					this.chainLaunchId = null;
+					this.parallelMode = true;
+					this.taskBackScreen = "parallel-builder";
+					this.taskEditor = createEditorState();
+					this.skipClarify = true;
+					this.screen = "task-input";
+				} else if (pAction?.type === "back") {
+					this.parallelState = null;
+					this.parallelMode = false;
+					this.screen = "list";
+				}
+				this.tui.requestRender();
+				return;
+			}
+			case "task-input": {
+				if (matchesKey(data, "tab")) { this.skipClarify = !this.skipClarify; this.tui.requestRender(); return; }
+				const innerW = this.overlayWidth - 2; const boxInnerWidth = Math.max(10, innerW - 4); const nextState = handleEditorInput(this.taskEditor, data, boxInnerWidth);
+				if (nextState) { this.taskEditor = nextState; this.tui.requestRender(); return; }
+				if (matchesKey(data, "escape") || matchesKey(data, "ctrl+c")) { this.screen = this.taskBackScreen; this.tui.requestRender(); return; }
+				if (matchesKey(data, "return")) {
+					if (this.chainLaunchId) {
+						const chainEntry = this.getChainEntry(this.chainLaunchId); if (!chainEntry) { this.screen = "list"; this.tui.requestRender(); return; }
+						this.done({ action: "launch-chain", chain: cloneChainConfig(chainEntry.config), task: this.taskEditor.buffer, skipClarify: this.skipClarify }); return;
+					} else if (this.parallelMode && this.parallelState) {
+						const sharedTask = this.taskEditor.buffer;
+						const tasks = this.parallelState.slots.map((slot) => ({ agent: slot.agentName, task: slot.customTask || sharedTask }));
+						this.done({ action: "parallel", tasks, skipClarify: this.skipClarify }); return;
+					}
+					const name = this.getAgentEntry(this.chainAgentIds[0] ?? null)?.config.name;
+					if (!name) { this.screen = "list"; this.tui.requestRender(); return; }
+					this.done({ action: "launch", agent: name, task: this.taskEditor.buffer, skipClarify: this.skipClarify }); return;
+				}
+				return;
+			}
+			case "confirm-delete": {
+				const agent = this.getAgentEntry(this.confirmDeleteId); const chain = this.getChainEntry(this.confirmDeleteId); if (!agent && !chain) { this.screen = "list"; this.tui.requestRender(); return; }
+				if (data === "y" || data === "Y") {
+					try { if (agent) { fs.unlinkSync(agent.config.filePath); this.removeAgentEntry(agent); } else if (chain) { fs.unlinkSync(chain.config.filePath); this.removeChainEntry(chain); } this.confirmDeleteId = null; this.screen = "list"; this.tui.requestRender(); return; }
+					catch (err) { this.statusMessage = { text: err instanceof Error ? err.message : "Failed to delete item.", type: "error" }; this.confirmDeleteId = null; this.screen = "list"; this.tui.requestRender(); return; }
+				}
+				if (data === "n" || data === "N" || matchesKey(data, "escape") || matchesKey(data, "ctrl+c")) { this.confirmDeleteId = null; this.screen = "list"; this.tui.requestRender(); return; }
+				return;
+			}
+			case "name-input": this.handleNameInput(data); return;
+			case "chain-edit": {
+				if (!this.chainEditState) { this.screen = "chain-detail"; this.tui.requestRender(); return; }
+				if (matchesKey(data, "ctrl+s")) { this.saveChainEdit(); this.tui.requestRender(); return; }
+				const innerW = this.overlayWidth - 2; const boxInnerWidth = Math.max(10, innerW - 4);
+				if (matchesKey(data, "shift+up") || matchesKey(data, "pageup") || matchesKey(data, "shift+down") || matchesKey(data, "pagedown")) {
+					const { lines: wrapped, starts } = wrapText(this.chainEditState.editor.buffer, boxInnerWidth); const cursorPos = getCursorDisplayPos(this.chainEditState.editor.cursor, starts);
+					const dir = matchesKey(data, "shift+up") || matchesKey(data, "pageup") ? -1 : 1; const targetLine = Math.max(0, Math.min(wrapped.length - 1, cursorPos.line + dir * CHAIN_EDIT_VIEWPORT));
+					const targetCol = Math.min(cursorPos.col, wrapped[targetLine]?.length ?? 0); this.chainEditState.editor = { ...this.chainEditState.editor, cursor: starts[targetLine] + targetCol }; this.tui.requestRender(); return;
+				}
+				const nextState = handleEditorInput(this.chainEditState.editor, data, boxInnerWidth, { multiLine: true });
+				if (nextState) { this.chainEditState.editor = nextState; this.tui.requestRender(); return; }
+				if (matchesKey(data, "escape") || matchesKey(data, "ctrl+c")) { this.chainEditState = null; this.screen = "chain-detail"; this.tui.requestRender(); return; }
+				return;
+			}
+			case "edit": case "edit-field": case "edit-prompt": {
+				if (!this.editState) { this.screen = "list"; this.tui.requestRender(); return; }
+				const result = handleEditInput(this.screen as EditScreen, this.editState, data, this.overlayWidth, this.models, this.skills);
+				if (result?.action === "discard") { this.handleEditDiscard(); return; }
+				if (result?.action === "save") { const ok = this.saveEdit(); if (ok) { const entry = this.getAgentEntry(this.currentAgentId); if (entry) this.enterDetail(entry); } this.tui.requestRender(); return; }
+				if (result?.nextScreen) this.screen = result.nextScreen; this.tui.requestRender(); return;
+			}
+		}
+	}
+
+	private handleEditDiscard(): void {
+		const entry = this.getAgentEntry(this.currentAgentId); if (!entry) { this.screen = "list"; this.editState = null; this.tui.requestRender(); return; }
+		if (entry.isNew) { this.removeAgentEntry(entry); this.editState = null; this.screen = "list"; this.tui.requestRender(); return; }
+		this.editState = null; this.enterDetail(entry); this.tui.requestRender();
+	}
+
+	private isBuiltin(id: string): boolean { const a = this.getAgentEntry(id); return a?.config.source === "builtin"; }
+
+	private handleListAction(action: ListAction): void {
+		switch (action.type) {
+			case "open-detail": { const agent = this.getAgentEntry(action.id); if (agent) { this.enterDetail(agent); return; } const chain = this.getChainEntry(action.id); if (chain) this.enterChainDetail(chain); return; }
+			case "clone": if (this.getAgentEntry(action.id)) this.enterNameInput("clone-agent", action.id); else if (this.getChainEntry(action.id)) this.enterNameInput("clone-chain", action.id); return;
+			case "new": this.enterTemplateSelect(); return;
+			case "delete": { if (this.isBuiltin(action.id)) { this.statusMessage = { text: "Builtin agents cannot be deleted. Clone to user scope to override.", type: "error" }; return; } this.confirmDeleteId = action.id; this.screen = "confirm-delete"; return; }
+			case "run-chain": this.enterTaskInput(action.ids); return;
+			case "run-parallel": this.enterParallelBuilder(action.ids); return;
+			case "close": this.done(undefined); return;
+		}
+	}
+
+	private handleDetailAction(action: DetailAction, entry: AgentEntry): void {
+		if (action.type === "back") { this.screen = "list"; return; }
+		if (action.type === "edit") { if (entry.config.source === "builtin") { this.statusMessage = { text: "Builtin agents cannot be edited. Clone to user scope to override.", type: "error" }; this.screen = "list"; return; } this.enterEdit(entry); return; }
+		if (action.type === "launch") { this.enterTaskInput([entry.id], "detail"); return; }
+	}
+
+	private handleChainDetailAction(action: ChainDetailAction, entry: ChainEntry): void {
+		if (action.type === "back") { this.screen = "list"; return; }
+		if (action.type === "launch") { this.enterSavedChainLaunch(entry); return; }
+		if (action.type === "edit") this.enterChainEdit(entry);
+	}
+
+	render(width: number): string[] {
+		this.overlayWidth = Math.min(width, 84); const w = this.overlayWidth;
+		switch (this.screen) {
+			case "list": return renderList(this.listState, this.listAgents(), w, this.theme, this.statusMessage);
+			case "template-select": return this.renderTemplateSelect(w);
+			case "detail": { const entry = this.getAgentEntry(this.currentAgentId); if (!entry) return renderList(this.listState, this.listAgents(), w, this.theme, this.statusMessage); return renderDetail(this.detailState, entry.config, this.agentData.cwd, w, this.theme); }
+			case "chain-detail": { const entry = this.getChainEntry(this.currentChainId); if (!entry) return renderList(this.listState, this.listAgents(), w, this.theme, this.statusMessage); return renderChainDetail(this.chainDetailState, entry.config, w, this.theme); }
+			case "edit": case "edit-field": case "edit-prompt": return this.editState ? renderEdit(this.screen as EditScreen, this.editState, w, this.theme) : [];
+			case "parallel-builder": {
+				if (!this.parallelState) return renderList(this.listState, this.listAgents(), w, this.theme, this.statusMessage);
+				const agentOptions: AgentOption[] = this.agents.map((e) => ({ name: e.config.name, description: e.config.description, model: e.config.model }));
+				return renderParallel(this.parallelState, agentOptions, w, this.theme);
+			}
+			case "task-input": {
+				if (this.chainLaunchId) { const entry = this.getChainEntry(this.chainLaunchId); const title = entry ? `Chain: ${entry.config.name}` : "Chain"; return renderTaskInput(title, this.taskEditor, this.skipClarify, w, this.theme); }
+				if (this.parallelMode && this.parallelState) return renderTaskInput(formatParallelTitle(this.parallelState.slots), this.taskEditor, this.skipClarify, w, this.theme);
+				const name = this.getAgentEntry(this.chainAgentIds[0] ?? null)?.config.name ?? "Agent";
+				return renderTaskInput(`Run: ${name}`, this.taskEditor, this.skipClarify, w, this.theme);
+			}
+			case "confirm-delete": return this.renderConfirmDelete(w);
+			case "name-input": return this.renderNameInput(w);
+			case "chain-edit": return this.renderChainEdit(w);
+		}
+	}
+
+	invalidate(): void {}
+	dispose(): void {}
+}

package/extensions/dm-subagents/agent-scope.ts

@@ -0,0 +1,6 @@
+import type { AgentScope } from "./agents.ts";
+
+export function resolveExecutionAgentScope(scope: unknown): AgentScope {
+	if (scope === "user" || scope === "project" || scope === "both") return scope;
+	return "both";
+}

package/extensions/dm-subagents/agent-selection.ts

@@ -0,0 +1,23 @@
+import type { AgentScope, AgentConfig } from "./agents.ts";
+
+export function mergeAgentsForScope(
+	scope: AgentScope,
+	userAgents: AgentConfig[],
+	projectAgents: AgentConfig[],
+	builtinAgents: AgentConfig[] = [],
+): AgentConfig[] {
+	const agentMap = new Map<string, AgentConfig>();
+
+	for (const agent of builtinAgents) agentMap.set(agent.name, agent);
+
+	if (scope === "both") {
+		for (const agent of userAgents) agentMap.set(agent.name, agent);
+		for (const agent of projectAgents) agentMap.set(agent.name, agent);
+	} else if (scope === "user") {
+		for (const agent of userAgents) agentMap.set(agent.name, agent);
+	} else {
+		for (const agent of projectAgents) agentMap.set(agent.name, agent);
+	}
+
+	return Array.from(agentMap.values());
+}

package/extensions/dm-subagents/agent-serializer.ts

@@ -0,0 +1,115 @@
+import * as fs from "node:fs";
+import type { AgentConfig } from "./agents.ts";
+
+export const KNOWN_FIELDS = new Set([
+	"name",
+	"description",
+	"tools",
+	"model",
+	"fallbackModels",
+	"thinking",
+	"skill",
+	"skills",
+	"extensions",
+	"output",
+	"defaultReads",
+	"defaultProgress",
+	"interactive",
+	"maxSubagentDepth",
+]);
+
+function joinComma(values: string[] | undefined): string | undefined {
+	if (!values || values.length === 0) return undefined;
+	return values.join(", ");
+}
+
+export function serializeAgent(config: AgentConfig): string {
+	const lines: string[] = [];
+	lines.push("---");
+	lines.push(`name: ${config.name}`);
+	lines.push(`description: ${config.description}`);
+
+	const tools = [
+		...(config.tools ?? []),
+		...(config.mcpDirectTools ?? []).map((tool) => `mcp:${tool}`),
+	];
+	const toolsValue = joinComma(tools);
+	if (toolsValue) lines.push(`tools: ${toolsValue}`);
+
+	if (config.model) lines.push(`model: ${config.model}`);
+	const fallbackModelsValue = joinComma(config.fallbackModels);
+	if (fallbackModelsValue) lines.push(`fallbackModels: ${fallbackModelsValue}`);
+	if (config.thinking && config.thinking !== "off") lines.push(`thinking: ${config.thinking}`);
+
+	const skillsValue = joinComma(config.skills);
+	if (skillsValue) lines.push(`skills: ${skillsValue}`);
+
+	if (config.extensions !== undefined) {
+		const extensionsValue = joinComma(config.extensions);
+		lines.push(`extensions: ${extensionsValue ?? ""}`);
+	}
+
+	if (config.output) lines.push(`output: ${config.output}`);
+
+	const readsValue = joinComma(config.defaultReads);
+	if (readsValue) lines.push(`defaultReads: ${readsValue}`);
+
+	if (config.defaultProgress) lines.push("defaultProgress: true");
+	if (config.interactive) lines.push("interactive: true");
+	if (Number.isInteger(config.maxSubagentDepth) && config.maxSubagentDepth >= 0) {
+		lines.push(`maxSubagentDepth: ${config.maxSubagentDepth}`);
+	}
+
+	if (config.extraFields) {
+		for (const [key, value] of Object.entries(config.extraFields)) {
+			if (KNOWN_FIELDS.has(key)) continue;
+			lines.push(`${key}: ${value}`);
+		}
+	}
+
+	lines.push("---");
+
+	const body = config.systemPrompt ?? "";
+	return `${lines.join("\n")}\n\n${body}\n`;
+}
+
+export function updateFrontmatterField(filePath: string, field: string, value: string | undefined): void {
+	const raw = fs.readFileSync(filePath, "utf-8");
+	const normalized = raw.replace(/\r\n/g, "\n");
+	if (!normalized.startsWith("---")) {
+		throw new Error("Frontmatter not found");
+	}
+
+	const endIndex = normalized.indexOf("\n---", 3);
+	if (endIndex === -1) {
+		throw new Error("Frontmatter not found");
+	}
+
+	const frontmatterBlock = normalized.slice(4, endIndex);
+	const rest = normalized.slice(endIndex + 4);
+	const lines = frontmatterBlock.split("\n");
+
+	const normalizedField = field === "skill" || field === "skills" ? "skills" : field;
+	const targetKeys = field === "skills" ? new Set(["skill", "skills"]) : new Set([field]);
+	let found = false;
+	const updated: string[] = [];
+
+	for (const line of lines) {
+		const match = line.match(/^([\w-]+):\s*(.*)$/);
+		if (match && targetKeys.has(match[1])) {
+			if (value !== undefined) {
+				if (!found) updated.push(`${normalizedField}: ${value}`);
+				found = true;
+			}
+			continue;
+		}
+		updated.push(line);
+	}
+
+	if (value !== undefined && !found) {
+		updated.push(`${normalizedField}: ${value}`);
+	}
+
+	const frontmatter = `---\n${updated.join("\n")}\n---`;
+	fs.writeFileSync(filePath, frontmatter + rest, "utf-8");
+}

package/extensions/dm-subagents/agent-templates.ts

@@ -0,0 +1,60 @@
+import type { AgentConfig } from "./agents.ts";
+
+export interface AgentTemplate {
+	name: string;
+	config: Partial<AgentConfig>;
+}
+
+export type TemplateItem =
+	| { type: "agent"; name: string; config: Partial<AgentConfig> }
+	| { type: "chain"; name: string; description: string }
+	| { type: "separator"; label: string };
+
+export const TEMPLATE_ITEMS: TemplateItem[] = [
+	{ type: "separator", label: "Agents" },
+	{
+		type: "agent",
+		name: "Blank",
+		config: { description: "Describe this agent", systemPrompt: "" },
+	},
+	{
+		type: "agent",
+		name: "Scout",
+		config: {
+			description: "Analyzes codebases and reports findings",
+			systemPrompt: "You are a code analysis agent. Given a codebase and a question, thoroughly investigate the relevant files and report your findings. Focus on accuracy — read the actual code rather than guessing.",
+			tools: ["read", "bash"],
+			output: "analysis.md",
+		},
+	},
+	{
+		type: "agent",
+		name: "Code Reviewer",
+		config: {
+			description: "Reviews code for bugs, style, and correctness",
+			systemPrompt: "You are a code review agent. Examine the code changes or files provided and identify bugs, style issues, performance concerns, and correctness problems. Be specific — cite line numbers and explain why each issue matters.",
+			tools: ["read", "bash"],
+		},
+	},
+	{
+		type: "agent",
+		name: "Planner",
+		config: {
+			description: "Creates implementation plans from requirements",
+			systemPrompt: "You are a planning agent. Given a task or requirements, create a detailed implementation plan. Break the work into concrete steps, identify which files need changes, and note any risks or dependencies.",
+			tools: ["read", "bash"],
+			output: "plan.md",
+		},
+	},
+	{
+		type: "agent",
+		name: "Implementer",
+		config: {
+			description: "Implements code changes from a plan",
+			systemPrompt: "You are an implementation agent. Given a plan or task, make the necessary code changes. Write clean, tested code that follows existing patterns. Run tests after making changes.",
+			defaultProgress: true,
+		},
+	},
+	{ type: "separator", label: "Chains" },
+	{ type: "chain", name: "Blank Chain", description: "Empty chain to configure" },
+];