@bastani/atomic 0.9.12 → 0.9.13-alpha.2

package/dist/builtin/subagents/src/agents/agent-management-helpers.ts

@@ -1,6 +1,6 @@
 import { MAX_SUBAGENT_NESTING_DEPTH, type SubagentToolResult } from "../shared/types.ts";
 import type { ManagementContext, ManagementScope } from "./agent-management.ts";
-import type { AgentConfig, AgentScope, ChainConfig, ChainStepConfig } from "./agents.ts";
+import type { AgentConfig, AgentScope } from "./agents.ts";
 import { discoverAgentsAll, parsePackageName } from "./agents.ts";
 import { discoverAvailableSkills } from "./skills.ts";
 
@@ -66,10 +66,9 @@ export function allAgents(d: { builtin: AgentConfig[]; user: AgentConfig[]; proj
 	return [...d.builtin, ...d.user, ...d.project];
 }
 
-export function availableNames(cwd: string, kind: "agent" | "chain"): string[] {
+export function availableNames(cwd: string): string[] {
 	const d = discoverAgentsAll(cwd);
-	const items = kind === "agent" ? allAgents(d) : d.chains;
-	return [...new Set(items.map((x) => x.name))].sort((a, b) => a.localeCompare(b));
+	return [...new Set(allAgents(d).map((agent) => agent.name))].sort((a, b) => a.localeCompare(b));
 }
 
 export function findAgents(name: string, cwd: string, scope: AgentScope = "both"): AgentConfig[] {
@@ -81,71 +80,11 @@ export function findAgents(name: string, cwd: string, scope: AgentScope = "both"
 		.sort((a, b) => a.source.localeCompare(b.source));
 }
 
-export function findChains(name: string, cwd: string, scope: AgentScope = "both"): ChainConfig[] {
-	const raw = name.trim();
-	const sanitized = sanitizeName(raw);
-	return discoverAgentsAll(cwd)
-		.chains.filter((c) => (scope === "both" || c.source === scope) && (c.name === raw || c.name === sanitized))
-		.sort((a, b) => a.source.localeCompare(b.source));
-}
-
 export function nameExistsInScope(cwd: string, scope: ManagementScope, name: string, excludePath?: string): boolean {
 	const d = discoverAgentsAll(cwd);
-	for (const a of scope === "user" ? d.user : d.project) {
-		if (a.name === name && a.filePath !== excludePath) return true;
-	}
-	for (const c of d.chains) {
-		if (c.source === scope && c.name === name && c.filePath !== excludePath) return true;
-	}
-	return false;
-}
-
-export function chainStepAgentNames(step: ChainStepConfig): string[] {
-	const names: string[] = [];
-	if (typeof step.agent === "string") names.push(step.agent);
-	const parallel = step.parallel;
-	if (Array.isArray(parallel)) {
-		for (const item of parallel) {
-			if (item && typeof item === "object") {
-				const agent = (item as { agent?: unknown }).agent;
-				if (typeof agent === "string") names.push(agent);
-			}
-		}
-	} else if (parallel && typeof parallel === "object") {
-		const agent = (parallel as { agent?: unknown }).agent;
-		if (typeof agent === "string") names.push(agent);
-	}
-	return names;
-}
-
-export function unknownChainAgents(cwd: string, steps: ChainStepConfig[]): string[] {
-	const d = discoverAgentsAll(cwd);
-	const known = new Set(allAgents(d).map((a) => a.name));
-	const unknown = steps.flatMap((step) => chainStepAgentNames(step)).filter((agent) => !known.has(agent));
-	return [...new Set(unknown)].sort((a, b) => a.localeCompare(b));
-}
-
-export function chainStepWarnings(ctx: ManagementContext, steps: ChainStepConfig[]): string[] {
-	const warnings: string[] = [];
-	const available = new Set(discoverAvailableSkills(ctx.cwd).map((s) => s.name));
-	for (let i = 0; i < steps.length; i++) {
-		const s = steps[i]!;
-		if (s.model) {
-			const found = ctx.modelRegistry
-				.getAvailable()
-				.some((m) => `${m.provider}/${m.id}` === s.model || m.id === s.model);
-			if (!found)
-				warnings.push(
-					`Warning: step ${i + 1} (${s.agent}): model '${s.model}' is not in the current model registry.`,
-				);
-		}
-		if (Array.isArray(s.skills) && s.skills.length > 0) {
-			const missing = s.skills.filter((sk) => !available.has(sk));
-			if (missing.length)
-				warnings.push(`Warning: step ${i + 1} (${s.agent}): skills not found: ${missing.join(", ")}.`);
-		}
-	}
-	return warnings;
+	return (scope === "user" ? d.user : d.project).some(
+		(agent) => agent.name === name && agent.filePath !== excludePath,
+	);
 }
 
 export function modelWarning(ctx: ManagementContext, model: string | undefined): string | undefined {
@@ -173,74 +112,6 @@ export function skillsWarning(cwd: string, skills: string[] | undefined): string
 	return missing.length ? `Warning: skills not found: ${missing.join(", ")}.` : undefined;
 }
 
-export function parseStepList(raw: unknown): { steps?: ChainStepConfig[]; error?: string } {
-	if (!Array.isArray(raw)) return { error: "config.steps must be an array." };
-	if (raw.length === 0) return { error: "config.steps must include at least one step." };
-	const steps: ChainStepConfig[] = [];
-	for (let i = 0; i < raw.length; i++) {
-		const item = raw[i];
-		if (!item || typeof item !== "object" || Array.isArray(item))
-			return { error: `config.steps[${i}] must be an object.` };
-		const s = item as Record<string, unknown>;
-		if (typeof s.agent !== "string" || !s.agent.trim())
-			return { error: `config.steps[${i}].agent must be a non-empty string.` };
-		const step: ChainStepConfig = { agent: s.agent.trim(), task: typeof s.task === "string" ? s.task : "" };
-		if (hasKey(s, "phase")) {
-			if (typeof s.phase === "string") step.phase = s.phase;
-			else return { error: `config.steps[${i}].phase must be a string.` };
-		}
-		if (hasKey(s, "label")) {
-			if (typeof s.label === "string") step.label = s.label;
-			else return { error: `config.steps[${i}].label must be a string.` };
-		}
-		if (hasKey(s, "as")) {
-			if (typeof s.as === "string") step.as = s.as;
-			else return { error: `config.steps[${i}].as must be a string.` };
-		}
-		if (hasKey(s, "outputSchema")) {
-			if (typeof s.outputSchema === "string") step.outputSchema = s.outputSchema;
-			else return { error: `config.steps[${i}].outputSchema must be a schema file path string for saved chains.` };
-		}
-		if (hasKey(s, "output")) {
-			if (s.output === false) step.output = false;
-			else if (typeof s.output === "string") step.output = s.output;
-			else return { error: `config.steps[${i}].output must be a string or false.` };
-		}
-		if (hasKey(s, "outputMode")) {
-			if (s.outputMode === "inline" || s.outputMode === "file-only") step.outputMode = s.outputMode;
-			else return { error: `config.steps[${i}].outputMode must be 'inline' or 'file-only'.` };
-		}
-		if (hasKey(s, "reads")) {
-			if (s.reads === false) step.reads = false;
-			else if (Array.isArray(s.reads))
-				step.reads = s.reads
-					.filter((v): v is string => typeof v === "string")
-					.map((v) => v.trim())
-					.filter(Boolean);
-			else return { error: `config.steps[${i}].reads must be an array or false.` };
-		}
-		if (hasKey(s, "model")) {
-			if (typeof s.model === "string") step.model = s.model;
-			else return { error: `config.steps[${i}].model must be a string.` };
-		}
-		if (hasKey(s, "skills")) {
-			if (s.skills === false) step.skills = false;
-			else if (Array.isArray(s.skills))
-				step.skills = s.skills
-					.filter((v): v is string => typeof v === "string")
-					.map((v) => v.trim())
-					.filter(Boolean);
-			else return { error: `config.steps[${i}].skills must be an array or false.` };
-		}
-		if (hasKey(s, "progress")) {
-			if (typeof s.progress === "boolean") step.progress = s.progress;
-			else return { error: `config.steps[${i}].progress must be a boolean.` };
-		}
-		steps.push(step);
-	}
-	return { steps };
-}
-
 export function parseTools(raw: string): { tools?: string[]; mcpDirectTools?: string[] } {
 	const tools: string[] = [];
 	const mcpDirectTools: string[] = [];

package/dist/builtin/subagents/src/agents/agent-management.ts

@@ -8,36 +8,29 @@ import {
 	applyAgentConfig,
 	asDisambiguationScope,
 	availableNames,
-	chainStepWarnings,
 	configObject,
 	fallbackModelsWarning,
 	findAgents,
-	findChains,
 	hasKey,
 	modelWarning,
 	nameExistsInScope,
 	normalizeListScope,
 	parsePackageConfig,
-	parseStepList,
 	result,
 	sanitizeName,
 	skillsWarning,
-	unknownChainAgents,
 } from "./agent-management-helpers.ts";
 import { serializeAgent } from "./agent-serializer.ts";
 import {
 	type AgentConfig,
 	type AgentSource,
 	buildRuntimeName,
-	type ChainConfig,
-	type ChainStepConfig,
 	defaultInheritProjectContext,
 	defaultInheritSkills,
 	defaultSystemPromptMode,
 	discoverAgentsAll,
 	frontmatterNameForConfig,
 } from "./agents.ts";
-import { serializeChain, serializeJsonChain } from "./chain-serializer.ts";
 
 type ManagementAction = "list" | "get" | "create" | "update" | "delete";
 export type ManagementScope = "user" | "project";
@@ -46,7 +39,6 @@ export type ManagementContext = Pick<ExtensionContext, "cwd" | "modelRegistry">;
 interface ManagementParams {
 	action?: string;
 	agent?: string;
-	chainName?: string;
 	agentScope?: string;
 	config?: unknown;
 }
@@ -57,8 +49,7 @@ function isMutableDefinition<T extends { source: AgentSource }>(value: T): value
 	return value.source === "user" || value.source === "project";
 }
 
-function resolveTarget<T extends { source: AgentSource; filePath: string }>(
-	kind: "agent" | "chain",
+function resolveTarget<T extends { source: AgentSource; filePath: string; name: string }>(
 	name: string,
 	matches: T[],
 	cwd: string,
@@ -66,40 +57,31 @@ function resolveTarget<T extends { source: AgentSource; filePath: string }>(
 ): MutableDefinition<T> | SubagentToolResult {
 	const mutable = matches.filter(isMutableDefinition);
 	if (mutable.length === 0) {
-		if (matches.length > 0) {
+		if (matches.length > 0)
 			return result(
-				`${kind === "agent" ? "Agent" : "Chain"} '${name}' is builtin and cannot be modified. Create a same-named ${kind} in user or project scope to override it.`,
+				`Agent '${name}' is builtin and cannot be modified. Create a same-named agent in user or project scope to override it.`,
 				true,
 			);
-		}
-		const available = availableNames(cwd, kind);
-		return result(
-			`${kind === "agent" ? "Agent" : "Chain"} '${name}' not found. Available: ${available.join(", ") || "none"}.`,
-			true,
-		);
+		const available = availableNames(cwd);
+		return result(`Agent '${name}' not found. Available: ${available.join(", ") || "none"}.`, true);
 	}
 	if (mutable.length === 1) return mutable[0]!;
 	const scope = asDisambiguationScope(scopeHint);
 	if (!scope) {
 		const paths = mutable.map((m) => `${m.source}: ${m.filePath}`).join("\n");
-		return result(
-			`${kind === "agent" ? "Agent" : "Chain"} '${name}' exists in both scopes. Specify agentScope: 'user' or 'project'.\n${paths}`,
-			true,
-		);
+		return result(`Agent '${name}' exists in both scopes. Specify agentScope: 'user' or 'project'.\n${paths}`, true);
 	}
 	const scoped = mutable.filter((m) => m.source === scope);
-	if (scoped.length === 0)
-		return result(`${kind === "agent" ? "Agent" : "Chain"} '${name}' not found in scope '${scope}'.`, true);
+	if (scoped.length === 0) return result(`Agent '${name}' not found in scope '${scope}'.`, true);
 	if (scoped.length > 1)
 		return result(
-			`Multiple ${kind}s named '${name}' found in scope '${scope}': ${scoped.map((m) => m.filePath).join(", ")}`,
+			`Multiple agents named '${name}' found in scope '${scope}': ${scoped.map((m) => m.filePath).join(", ")}`,
 			true,
 		);
 	return scoped[0]!;
 }
 
 function renamePath(
-	kind: "agent" | "chain",
 	currentPath: string,
 	newName: string,
 	scope: ManagementScope,
@@ -107,13 +89,11 @@ function renamePath(
 ): { filePath?: string; error?: string } {
 	if (nameExistsInScope(cwd, scope, newName, currentPath))
 		return { error: `Name '${newName}' already exists in ${scope} scope.` };
-	const ext = kind === "agent" ? ".md" : currentPath.endsWith(".chain.json") ? ".chain.json" : ".chain.md";
-	const filePath = path.join(path.dirname(currentPath), `${newName}${ext}`);
-	if (fs.existsSync(filePath) && filePath !== currentPath) {
+	const filePath = path.join(path.dirname(currentPath), `${newName}.md`);
+	if (fs.existsSync(filePath) && filePath !== currentPath)
 		return {
-			error: `File already exists at ${filePath} but is not a valid ${kind} definition. Remove or rename it first.`,
+			error: `File already exists at ${filePath} but is not a valid agent definition. Remove or rename it first.`,
 		};
-	}
 	fs.renameSync(currentPath, filePath);
 	return { filePath };
 }
@@ -149,130 +129,33 @@ function formatAgentDetail(agent: AgentConfig): string {
 	return lines.join("\n");
 }
 
-function formatChainStepDetail(step: ChainStepConfig, index: number): string[] {
-	const lines: string[] = [];
-	if (step.expand || step.collect) {
-		const parallel =
-			step.parallel && !Array.isArray(step.parallel) && typeof step.parallel === "object"
-				? (step.parallel as { agent?: unknown; task?: unknown; label?: unknown; outputSchema?: unknown })
-				: undefined;
-		const expand =
-			step.expand && typeof step.expand === "object"
-				? (step.expand as {
-						from?: { output?: unknown; path?: unknown };
-						item?: unknown;
-						key?: unknown;
-						maxItems?: unknown;
-						onEmpty?: unknown;
-					})
-				: undefined;
-		const collect =
-			step.collect && typeof step.collect === "object"
-				? (step.collect as { as?: unknown; outputSchema?: unknown })
-				: undefined;
-		lines.push(`${index + 1}. Dynamic fanout${typeof collect?.as === "string" ? ` -> ${collect.as}` : ""}`);
-		if (expand?.from) lines.push(`   Expand: ${String(expand.from.output ?? "?")}${String(expand.from.path ?? "")}`);
-		if (typeof expand?.item === "string") lines.push(`   Item variable: ${expand.item}`);
-		if (typeof expand?.key === "string") lines.push(`   Key: ${expand.key}`);
-		if (typeof expand?.maxItems === "number") lines.push(`   Max items: ${expand.maxItems}`);
-		if (typeof expand?.onEmpty === "string") lines.push(`   On empty: ${expand.onEmpty}`);
-		if (parallel?.agent) lines.push(`   Agent: ${String(parallel.agent)}`);
-		if (typeof parallel?.label === "string") lines.push(`   Label: ${parallel.label}`);
-		if (typeof parallel?.task === "string" && parallel.task.trim()) lines.push(`   Task: ${parallel.task}`);
-		if (parallel?.outputSchema) lines.push("   Structured output: true");
-		if (collect?.outputSchema) lines.push("   Collect schema: true");
-		if (step.concurrency !== undefined) lines.push(`   Concurrency: ${step.concurrency}`);
-		if (step.failFast !== undefined) lines.push(`   Fail fast: ${step.failFast ? "true" : "false"}`);
-		return lines;
-	}
-	lines.push(`${index + 1}. ${step.agent}`);
-	if (step.task?.trim()) lines.push(`   Task: ${step.task}`);
-	if (step.output === false) lines.push("   Output: false");
-	else if (step.output) lines.push(`   Output: ${step.output}`);
-	if (step.outputMode) lines.push(`   Output mode: ${step.outputMode}`);
-	if (step.reads === false) lines.push("   Reads: false");
-	else if (Array.isArray(step.reads) && step.reads.length > 0) lines.push(`   Reads: ${step.reads.join(", ")}`);
-	if (step.model) lines.push(`   Model: ${step.model}`);
-	if (step.skills === false) lines.push("   Skills: false");
-	else if (Array.isArray(step.skills) && step.skills.length > 0) lines.push(`   Skills: ${step.skills.join(", ")}`);
-	if (step.progress !== undefined) lines.push(`   Progress: ${step.progress ? "true" : "false"}`);
-	return lines;
-}
-
-function formatChainDetail(chain: ChainConfig): string {
-	const lines: string[] = [
-		`Chain: ${chain.name} (${chain.source})`,
-		`Path: ${chain.filePath}`,
-		`Description: ${chain.description}`,
-	];
-	if (chain.packageName) {
-		lines.push(`Local name: ${frontmatterNameForConfig(chain)}`);
-		lines.push(`Package: ${chain.packageName}`);
-	}
-	lines.push("", "Steps:");
-	for (let i = 0; i < chain.steps.length; i++) {
-		lines.push(...formatChainStepDetail(chain.steps[i]!, i));
-	}
-	return lines.join("\n");
-}
-
 export function handleList(params: ManagementParams, ctx: ManagementContext): SubagentToolResult {
 	const scope = normalizeListScope(params.agentScope) ?? "both";
 	const d = discoverAgentsAll(ctx.cwd);
-	const scopedAgents = allAgents(d)
-		.filter((a) => scope === "both" || a.source === "builtin" || a.source === scope)
+	const agents = allAgents(d)
+		.filter((agent) => !agent.disabled && (scope === "both" || agent.source === "builtin" || agent.source === scope))
 		.sort((a, b) => a.name.localeCompare(b.name));
-	const agents = scopedAgents.filter((a) => !a.disabled);
-	const chains = d.chains
-		.filter((c) => scope === "both" || c.source === scope)
-		.sort((a, b) => a.name.localeCompare(b.name));
-	const diagnostics = d.chainDiagnostics.filter((entry) => scope === "both" || entry.source === scope);
 	const lines = [
 		"Executable agents:",
 		...(agents.length
 			? agents.map(
-					(a) =>
-						`- ${a.name} (${a.source}${a.defaultContext ? `, context: ${a.defaultContext}` : ""}): ${a.description}`,
+					(agent) =>
+						`- ${agent.name} (${agent.source}${agent.defaultContext ? `, context: ${agent.defaultContext}` : ""}): ${agent.description}`,
 				)
 			: ["- (none)"]),
-		"",
-		"Chains:",
-		...(chains.length ? chains.map((c) => `- ${c.name} (${c.source}): ${c.description}`) : ["- (none)"]),
-		...(diagnostics.length
-			? ["", "Chain diagnostics:", ...diagnostics.map((entry) => `- ${entry.filePath}: ${entry.error}`)]
-			: []),
 	];
 	return result(lines.join("\n"));
 }
 
 function handleGet(params: ManagementParams, ctx: ManagementContext): SubagentToolResult {
-	if (!params.agent && !params.chainName) return result("Specify 'agent' or 'chainName' for get.", true);
-	const hasBoth = Boolean(params.agent && params.chainName);
-	const blocks: string[] = [];
-	let anyFound = false;
-	if (params.agent) {
-		const matches = findAgents(params.agent, ctx.cwd, "both");
-		if (!matches.length) {
-			const msg = `Agent '${params.agent}' not found. Available: ${availableNames(ctx.cwd, "agent").join(", ") || "none"}.`;
-			if (!hasBoth) return result(msg, true);
-			blocks.push(msg);
-		} else {
-			anyFound = true;
-			blocks.push(...matches.map(formatAgentDetail));
-		}
-	}
-	if (params.chainName) {
-		const matches = findChains(params.chainName, ctx.cwd, "both");
-		if (!matches.length) {
-			const msg = `Chain '${params.chainName}' not found. Available: ${availableNames(ctx.cwd, "chain").join(", ") || "none"}.`;
-			if (!hasBoth) return result(msg, true);
-			blocks.push(msg);
-		} else {
-			anyFound = true;
-			blocks.push(...matches.map(formatChainDetail));
-		}
-	}
-	return result(blocks.join("\n\n"), !anyFound);
+	if (!params.agent) return result("Specify 'agent' for get.", true);
+	const matches = findAgents(params.agent, ctx.cwd, "both");
+	if (!matches.length)
+		return result(
+			`Agent '${params.agent}' not found. Available: ${availableNames(ctx.cwd).join(", ") || "none"}.`,
+			true,
+		);
+	return result(matches.map(formatAgentDetail).join("\n\n"));
 }
 
 export function handleCreate(params: ManagementParams, ctx: ManagementContext): SubagentToolResult {
@@ -293,45 +176,20 @@ export function handleCreate(params: ManagementParams, ctx: ManagementContext):
 	const scopeRaw = cfg.scope ?? "user";
 	if (scopeRaw !== "user" && scopeRaw !== "project") return result("config.scope must be 'user' or 'project'.", true);
 	const scope = scopeRaw as ManagementScope;
-	const isChain = hasKey(cfg, "steps");
 	const d = discoverAgentsAll(ctx.cwd);
-	const targetDir = isChain
-		? scope === "user"
-			? d.userChainDir
-			: (d.projectChainDir ?? path.join(ctx.cwd, CONFIG_DIR_NAME, "chains"))
-		: scope === "user"
-			? d.userDir
-			: (d.projectDir ?? path.join(ctx.cwd, CONFIG_DIR_NAME, "agents"));
+	const targetDir = scope === "user" ? d.userDir : (d.projectDir ?? path.join(ctx.cwd, CONFIG_DIR_NAME, "agents"));
 	fs.mkdirSync(targetDir, { recursive: true });
 	if (nameExistsInScope(ctx.cwd, scope, runtimeName))
 		return result(`Name '${runtimeName}' already exists in ${scope} scope. Use update instead.`, true);
-	const targetPath = path.join(targetDir, isChain ? `${runtimeName}.chain.md` : `${runtimeName}.md`);
+	const targetPath = path.join(targetDir, `${runtimeName}.md`);
 	if (fs.existsSync(targetPath))
 		return result(
-			`File already exists at ${targetPath} but is not a valid ${isChain ? "chain" : "agent"} definition. Remove or rename it first.`,
+			`File already exists at ${targetPath} but is not a valid agent definition. Remove or rename it first.`,
 			true,
 		);
 	const warnings: string[] = [];
-	if (!isChain && d.builtin.some((a) => a.name === runtimeName))
+	if (d.builtin.some((a) => a.name === runtimeName))
 		warnings.push(`Note: this shadows the builtin agent '${runtimeName}'.`);
-	if (isChain) {
-		const parsed = parseStepList(cfg.steps);
-		if (parsed.error) return result(parsed.error, true);
-		const chain: ChainConfig = {
-			name: runtimeName,
-			localName: name,
-			packageName: parsedPackage.packageName,
-			description: cfg.description.trim(),
-			source: scope,
-			filePath: targetPath,
-			steps: parsed.steps!,
-		};
-		fs.writeFileSync(targetPath, serializeChain(chain), "utf-8");
-		const missing = unknownChainAgents(ctx.cwd, chain.steps);
-		if (missing.length) warnings.push(`Warning: chain steps reference unknown agents: ${missing.join(", ")}.`);
-		warnings.push(...chainStepWarnings(ctx, chain.steps));
-		return result([`Created chain '${runtimeName}' at ${targetPath}.`, ...warnings].join("\n"));
-	}
 	const agent: AgentConfig = {
 		name: runtimeName,
 		localName: name,
@@ -357,88 +215,22 @@ export function handleCreate(params: ManagementParams, ctx: ManagementContext):
 }
 
 export function handleUpdate(params: ManagementParams, ctx: ManagementContext): SubagentToolResult {
-	if (!params.agent && !params.chainName) return result("Specify 'agent' or 'chainName' for update.", true);
-	if (params.agent && params.chainName) return result("Specify either 'agent' or 'chainName', not both.", true);
+	if (!params.agent) return result("Specify 'agent' for update.", true);
 	const parsedConfig = configObject(params.config);
 	if (parsedConfig.error) return result(parsedConfig.error, true);
 	const cfg = parsedConfig.value;
 	if (!cfg) return result("config required for update.", true);
 	const warnings: string[] = [];
-	if (params.agent) {
-		const scopeHint = asDisambiguationScope(params.agentScope);
-		const targetOrError = resolveTarget(
-			"agent",
-			params.agent,
-			findAgents(params.agent, ctx.cwd, scopeHint ?? "both"),
-			ctx.cwd,
-			params.agentScope,
-		);
-		if ("content" in targetOrError) return targetOrError;
-		const target = targetOrError;
-		const updated: AgentConfig = { ...target };
-		const oldName = target.name;
-		if (hasKey(cfg, "name") && (typeof cfg.name !== "string" || !cfg.name.trim()))
-			return result("config.name must be a non-empty string when provided.", true);
-		if (hasKey(cfg, "description") && (typeof cfg.description !== "string" || !cfg.description.trim()))
-			return result("config.description must be a non-empty string when provided.", true);
-		let newLocalName = target.localName ?? frontmatterNameForConfig(target);
-		if (hasKey(cfg, "name")) {
-			newLocalName = sanitizeName(cfg.name as string);
-			if (!newLocalName) return result("config.name is invalid after sanitization.", true);
-		}
-		let newPackageName = target.packageName;
-		if (hasKey(cfg, "package")) {
-			const parsedPackage = parsePackageConfig(cfg.package);
-			if (parsedPackage.error) return result(parsedPackage.error, true);
-			newPackageName = parsedPackage.packageName;
-		}
-		const applyError = applyAgentConfig(updated, cfg);
-		if (applyError) return result(applyError, true);
-		updated.localName = newLocalName;
-		updated.packageName = newPackageName;
-		updated.name = buildRuntimeName(newLocalName, newPackageName);
-		if (hasKey(cfg, "description")) updated.description = (cfg.description as string).trim();
-		if (hasKey(cfg, "model")) {
-			const mw = modelWarning(ctx, updated.model);
-			if (mw) warnings.push(mw);
-		}
-		if (hasKey(cfg, "fallbackModels")) {
-			const fmw = fallbackModelsWarning(ctx, updated.fallbackModels);
-			if (fmw) warnings.push(fmw);
-		}
-		if (hasKey(cfg, "skills")) {
-			const sw = skillsWarning(ctx.cwd, updated.skills);
-			if (sw) warnings.push(sw);
-		}
-		if (updated.name !== oldName) {
-			const renamed = renamePath("agent", target.filePath, updated.name, target.source, ctx.cwd);
-			if (renamed.error) return result(renamed.error, true);
-			updated.filePath = renamed.filePath!;
-		}
-		fs.writeFileSync(updated.filePath, serializeAgent(updated), "utf-8");
-		if (updated.name !== oldName) {
-			const refs = discoverAgentsAll(ctx.cwd)
-				.chains.filter((c) => c.steps.some((s) => s.agent === oldName))
-				.map((c) => `${c.name} (${c.source})`);
-			if (refs.length) warnings.push(`Warning: chains still reference '${oldName}': ${refs.join(", ")}.`);
-		}
-		const headline =
-			updated.name === oldName
-				? `Updated agent '${updated.name}' at ${updated.filePath}.`
-				: `Updated agent '${oldName}' to '${updated.name}' at ${updated.filePath}.`;
-		return result([headline, ...warnings].join("\n"));
-	}
 	const scopeHint = asDisambiguationScope(params.agentScope);
 	const targetOrError = resolveTarget(
-		"chain",
-		params.chainName!,
-		findChains(params.chainName!, ctx.cwd, scopeHint ?? "both"),
+		params.agent,
+		findAgents(params.agent, ctx.cwd, scopeHint ?? "both"),
 		ctx.cwd,
 		params.agentScope,
 	);
 	if ("content" in targetOrError) return targetOrError;
 	const target = targetOrError;
-	const updated: ChainConfig = { ...target, steps: [...target.steps] };
+	const updated: AgentConfig = { ...target };
 	const oldName = target.name;
 	if (hasKey(cfg, "name") && (typeof cfg.name !== "string" || !cfg.name.trim()))
 		return result("config.name must be a non-empty string when provided.", true);
@@ -455,72 +247,50 @@ export function handleUpdate(params: ManagementParams, ctx: ManagementContext):
 		if (parsedPackage.error) return result(parsedPackage.error, true);
 		newPackageName = parsedPackage.packageName;
 	}
-	let parsedSteps: ChainStepConfig[] | undefined;
-	if (hasKey(cfg, "steps")) {
-		const parsed = parseStepList(cfg.steps);
-		if (parsed.error) return result(parsed.error, true);
-		parsedSteps = parsed.steps!;
-	}
+	const applyError = applyAgentConfig(updated, cfg);
+	if (applyError) return result(applyError, true);
 	updated.localName = newLocalName;
 	updated.packageName = newPackageName;
 	updated.name = buildRuntimeName(newLocalName, newPackageName);
 	if (hasKey(cfg, "description")) updated.description = (cfg.description as string).trim();
-	if (parsedSteps) {
-		updated.steps = parsedSteps;
-		const missing = unknownChainAgents(ctx.cwd, updated.steps);
-		if (missing.length) warnings.push(`Warning: chain steps reference unknown agents: ${missing.join(", ")}.`);
-		warnings.push(...chainStepWarnings(ctx, updated.steps));
+	if (hasKey(cfg, "model")) {
+		const warning = modelWarning(ctx, updated.model);
+		if (warning) warnings.push(warning);
+	}
+	if (hasKey(cfg, "fallbackModels")) {
+		const warning = fallbackModelsWarning(ctx, updated.fallbackModels);
+		if (warning) warnings.push(warning);
+	}
+	if (hasKey(cfg, "skills")) {
+		const warning = skillsWarning(ctx.cwd, updated.skills);
+		if (warning) warnings.push(warning);
 	}
 	if (updated.name !== oldName) {
-		const renamed = renamePath("chain", target.filePath, updated.name, target.source, ctx.cwd);
+		const renamed = renamePath(target.filePath, updated.name, target.source, ctx.cwd);
 		if (renamed.error) return result(renamed.error, true);
 		updated.filePath = renamed.filePath!;
 	}
-	fs.writeFileSync(
-		updated.filePath,
-		updated.filePath.endsWith(".chain.json") ? serializeJsonChain(updated) : serializeChain(updated),
-		"utf-8",
-	);
+	fs.writeFileSync(updated.filePath, serializeAgent(updated), "utf-8");
 	const headline =
 		updated.name === oldName
-			? `Updated chain '${updated.name}' at ${updated.filePath}.`
-			: `Updated chain '${oldName}' to '${updated.name}' at ${updated.filePath}.`;
+			? `Updated agent '${updated.name}' at ${updated.filePath}.`
+			: `Updated agent '${oldName}' to '${updated.name}' at ${updated.filePath}.`;
 	return result([headline, ...warnings].join("\n"));
 }
 
 function handleDelete(params: ManagementParams, ctx: ManagementContext): SubagentToolResult {
-	if (!params.agent && !params.chainName) return result("Specify 'agent' or 'chainName' for delete.", true);
-	if (params.agent && params.chainName) return result("Specify either 'agent' or 'chainName', not both.", true);
+	if (!params.agent) return result("Specify 'agent' for delete.", true);
 	const scopeHint = asDisambiguationScope(params.agentScope);
-	if (params.agent) {
-		const targetOrError = resolveTarget(
-			"agent",
-			params.agent,
-			findAgents(params.agent, ctx.cwd, scopeHint ?? "both"),
-			ctx.cwd,
-			params.agentScope,
-		);
-		if ("content" in targetOrError) return targetOrError;
-		const target = targetOrError;
-		fs.unlinkSync(target.filePath);
-		const refs = discoverAgentsAll(ctx.cwd)
-			.chains.filter((c) => c.steps.some((s) => s.agent === target.name))
-			.map((c) => `${c.name} (${c.source})`);
-		const lines = [`Deleted agent '${target.name}' at ${target.filePath}.`];
-		if (refs.length) lines.push(`Warning: chains reference deleted agent '${target.name}': ${refs.join(", ")}.`);
-		return result(lines.join("\n"));
-	}
 	const targetOrError = resolveTarget(
-		"chain",
-		params.chainName!,
-		findChains(params.chainName!, ctx.cwd, scopeHint ?? "both"),
+		params.agent,
+		findAgents(params.agent, ctx.cwd, scopeHint ?? "both"),
 		ctx.cwd,
 		params.agentScope,
 	);
 	if ("content" in targetOrError) return targetOrError;
 	const target = targetOrError;
 	fs.unlinkSync(target.filePath);
-	return result(`Deleted chain '${target.name}' at ${target.filePath}.`);
+	return result(`Deleted agent '${target.name}' at ${target.filePath}.`);
 }
 
 export function handleManagementAction(