@dreki-gg/pi-subagent 0.5.0 → 0.7.0

package/extensions/subagent/index.ts

@@ -25,43 +25,30 @@ import { StringEnum } from '@mariozechner/pi-ai';
 import {
   type ExtensionAPI,
   type ExtensionCommandContext,
+  AuthStorage,
   DefaultPackageManager,
   getAgentDir,
   getMarkdownTheme,
+  ModelRegistry,
   SettingsManager,
   withFileMutationQueue,
 } from '@mariozechner/pi-coding-agent';
 import type { ResolvedPaths } from '@mariozechner/pi-coding-agent';
-import { Container, Markdown, Spacer, Text } from '@mariozechner/pi-tui';
-import { Type } from '@sinclair/typebox';
+import { Box, Container, Markdown, Spacer, Text, type AutocompleteItem } from '@mariozechner/pi-tui';
+import { Type } from 'typebox';
 import {
   type AgentConfig,
   type AgentScope,
   type AgentSource,
   bundledAgentsDir,
-  discoverAgents,
   discoverAgentsWithPackages,
 } from './agents.js';
-import { formatDelegateUsage, parseDelegateArgs } from './delegate-args.js';
-import { runAgent, runParallel } from './delegate-executor.js';
-import { buildSynthesisPrompt, extractRecentConversation } from './synthesis.js';
-import type {
-  AgentResult,
-  DelegateState,
-  PhaseDefinition,
-  PhaseResult,
-  UsageStats as DelegateUsageStats,
-} from './delegate-types.js';
-import {
-  aggregateUsage,
-  confirmPlan,
-  confirmSynthesis,
-  formatFullSummary,
-  formatPhaseHeader,
-  getFinalText,
-  pickWorkflow,
-} from './delegate-ui.js';
-import { getWorkflow, suggestWorkflow } from './workflows.js';
+import { formatRunAgentUsage, parseRunAgentArgs } from './run-agent-args.js';
+import { runAgent } from './agent-runner.js';
+import { extractRecentConversation } from './synthesis.js';
+import type { AgentResult } from './agent-runner-types.js';
+import { getFinalText } from './agent-result-utils.js';
+import { buildHandoffFromResult, renderHandoffForPrompt } from './handoffs.js';
 
 const MAX_PARALLEL_TASKS = 8;
 const MAX_CONCURRENCY = 4;
@@ -182,6 +169,20 @@ interface UsageStats {
   turns: number;
 }
 
+interface RunAgentSummaryDetails {
+  agent: string;
+  agentSource: AgentSource;
+  agentScope: AgentScope;
+  sessionStrategy: string;
+  forked: boolean;
+  exitCode: number;
+  stopReason?: string;
+  errorMessage?: string;
+  usage: UsageStats;
+  task: string;
+  output: string;
+}
+
 interface SingleResult {
   agent: string;
   agentSource: AgentSource | 'unknown';
@@ -295,6 +296,8 @@ async function runSingleAgent(
   agentName: string,
   task: string,
   cwd: string | undefined,
+  modelOverride: string | undefined,
+  thinkingOverride: string | undefined,
   step: number | undefined,
   signal: AbortSignal | undefined,
   onUpdate: OnUpdateCallback | undefined,
@@ -324,9 +327,12 @@ async function runSingleAgent(
     };
   }
 
+  const selectedModel = modelOverride ?? agent.model;
+  const selectedThinking = thinkingOverride ?? agent.thinking;
+
   const args: string[] = ['--mode', 'json', '-p', '--no-session'];
-  if (agent.model) args.push('--model', agent.model);
-  if (agent.thinking) args.push('--thinking', agent.thinking);
+  if (selectedModel) args.push('--model', selectedModel);
+  if (selectedThinking) args.push('--thinking', selectedThinking);
   if (agent.tools && agent.tools.length > 0) args.push('--tools', agent.tools.join(','));
 
   let tmpPromptDir: string | null = null;
@@ -348,7 +354,7 @@ async function runSingleAgent(
       contextTokens: 0,
       turns: 0,
     },
-    model: agent.model,
+    model: selectedModel,
     step,
   };
 
@@ -473,12 +479,20 @@ async function runSingleAgent(
 const TaskItem = Type.Object({
   agent: Type.String({ description: 'Name of the agent to invoke' }),
   task: Type.String({ description: 'Task to delegate to the agent' }),
+  model: Type.Optional(Type.String({ description: 'Optional model override for this task' })),
+  thinking: Type.Optional(
+    Type.String({ description: 'Optional reasoning level override for this task' }),
+  ),
   cwd: Type.Optional(Type.String({ description: 'Working directory for the agent process' })),
 });
 
 const ChainItem = Type.Object({
   agent: Type.String({ description: 'Name of the agent to invoke' }),
   task: Type.String({ description: 'Task with optional {previous} placeholder for prior output' }),
+  model: Type.Optional(Type.String({ description: 'Optional model override for this step' })),
+  thinking: Type.Optional(
+    Type.String({ description: 'Optional reasoning level override for this step' }),
+  ),
   cwd: Type.Optional(Type.String({ description: 'Working directory for the agent process' })),
 });
 
@@ -493,11 +507,17 @@ const SubagentParams = Type.Object({
     Type.String({ description: 'Name of the agent to invoke (for single mode)' }),
   ),
   task: Type.Optional(Type.String({ description: 'Task to delegate (for single mode)' })),
+  model: Type.Optional(
+    Type.String({ description: 'Optional default model override for the run or all steps/tasks' }),
+  ),
+  thinking: Type.Optional(
+    Type.String({ description: 'Optional default reasoning level override for the run or all steps/tasks' }),
+  ),
   tasks: Type.Optional(
-    Type.Array(TaskItem, { description: 'Array of {agent, task} for parallel execution' }),
+    Type.Array(TaskItem, { description: 'Array of {agent, task, model?, thinking?} for parallel execution' }),
   ),
   chain: Type.Optional(
-    Type.Array(ChainItem, { description: 'Array of {agent, task} for sequential execution' }),
+    Type.Array(ChainItem, { description: 'Array of {agent, task, model?, thinking?} for sequential execution' }),
   ),
   agentScope: Type.Optional(AgentScopeSchema),
   confirmProjectAgents: Type.Optional(
@@ -532,12 +552,99 @@ async function tryResolvePackagePaths(cwd: string): Promise<ResolvedPaths | unde
 }
 
 export default function (pi: ExtensionAPI) {
+  let autocompleteCwd = process.cwd();
+
+  function parseArgumentText(argumentText: string): {
+    completedTokens: string[];
+    currentToken: string;
+  } {
+    const endsWithSpace = argumentText.length > 0 && /\s$/.test(argumentText);
+    const tokens = argumentText.trim().length > 0 ? argumentText.trim().split(/\s+/) : [];
+    return {
+      completedTokens: endsWithSpace ? tokens : tokens.slice(0, -1),
+      currentToken: endsWithSpace ? '' : (tokens.at(-1) ?? ''),
+    };
+  }
+
+  function replaceCurrentToken(argumentText: string, replacement: string): string {
+    const trimmedEnd = argumentText.replace(/\s+$/, '');
+    if (!trimmedEnd) return replacement;
+    if (/\s$/.test(argumentText)) return `${trimmedEnd} ${replacement}`;
+    const lastSpace = trimmedEnd.lastIndexOf(' ');
+    return lastSpace === -1
+      ? replacement
+      : `${trimmedEnd.slice(0, lastSpace + 1)}${replacement}`;
+  }
+
+  function buildArgumentCompletions(
+    argumentText: string,
+    items: Array<{ value: string; label?: string; description?: string }>,
+  ): AutocompleteItem[] | null {
+    const { currentToken } = parseArgumentText(argumentText);
+    const query = currentToken.toLowerCase();
+    const filtered = items.filter((item) => {
+      if (!query) return true;
+      return (
+        item.value.toLowerCase().startsWith(query) ||
+        item.label?.toLowerCase().includes(query) ||
+        item.description?.toLowerCase().includes(query)
+      );
+    });
+    if (filtered.length === 0) return null;
+    return filtered.map((item) => ({
+      value: replaceCurrentToken(argumentText, item.value),
+      label: item.label ?? item.value,
+      description: item.description,
+    }));
+  }
+
+  async function getAutocompleteAgents(scope: AgentScope): Promise<AgentConfig[]> {
+    const resolvedPaths = await tryResolvePackagePaths(autocompleteCwd);
+    return discoverAgentsWithPackages(autocompleteCwd, scope, resolvedPaths).agents;
+  }
+
+  async function getAutocompleteModels(scope: AgentScope): Promise<
+    Array<{ value: string; label?: string; description?: string }>
+  > {
+    const items = new Map<string, { value: string; label?: string; description?: string }>();
+
+    try {
+      const authStorage = AuthStorage.create();
+      const modelRegistry = ModelRegistry.create(authStorage);
+      const available = await modelRegistry.getAvailable();
+      for (const model of available) {
+        const value = `${model.provider}/${model.id}`;
+        items.set(value, {
+          value,
+          label: value,
+          description: 'Configured model with available credentials',
+        });
+      }
+    } catch {
+      // Fall back to models referenced by discovered agents.
+    }
+
+    const agents = await getAutocompleteAgents(scope);
+    for (const agent of agents) {
+      if (!agent.model) continue;
+      if (items.has(agent.model)) continue;
+      items.set(agent.model, {
+        value: agent.model,
+        label: agent.model,
+        description: `Default model on agent ${agent.name}`,
+      });
+    }
+
+    return [...items.values()];
+  }
+
   pi.registerTool({
     name: 'subagent',
     label: 'Subagent',
     description: [
       'Delegate tasks to specialized subagents with isolated context.',
       'Modes: single (agent + task), parallel (tasks array), chain (sequential with {previous} placeholder).',
+      'Optional per-run or per-step model and reasoning-level overrides are supported via model/thinking.',
       'Default agent scope is "user" (from ~/.pi/agent/agents).',
       'To enable project-local agents in .pi/agents, set agentScope: "both" (or "project").',
     ].join(' '),
@@ -635,6 +742,8 @@ export default function (pi: ExtensionAPI) {
             step.agent,
             taskWithContext,
             step.cwd,
+            step.model ?? params.model,
+            step.thinking ?? params.thinking,
             i + 1,
             signal,
             chainUpdate,
@@ -663,7 +772,15 @@ export default function (pi: ExtensionAPI) {
               isError: true,
             };
           }
-          previousOutput = getFinalOutput(result.messages);
+          const finalOutput = getFinalOutput(result.messages) || '(no output)';
+          previousOutput = renderHandoffForPrompt(
+            buildHandoffFromResult({
+              agent: step.agent,
+              step: i + 1,
+              task: step.task,
+              output: finalOutput,
+            }),
+          );
         }
         return {
           content: [
@@ -738,6 +855,8 @@ export default function (pi: ExtensionAPI) {
               t.agent,
               t.task,
               t.cwd,
+              t.model ?? params.model,
+              t.thinking ?? params.thinking,
               undefined,
               signal,
               // Per-task update callback
@@ -778,6 +897,8 @@ export default function (pi: ExtensionAPI) {
           params.agent,
           params.task,
           params.cwd,
+          params.model,
+          params.thinking,
           undefined,
           signal,
           onUpdate,
@@ -1145,84 +1266,132 @@ export default function (pi: ExtensionAPI) {
     },
   });
 
-  // ── Delegate commands ──────────────────────────────────────────────────────
-
-  function emptyDelegateUsage(): DelegateUsageStats {
-    return { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, contextTokens: 0, turns: 0 };
-  }
+  // ── Command helpers ───────────────────────────────────────────────────────
 
-  function combineParallelOutputs(results: AgentResult[]): string {
-    return results
-      .map((r) => {
-        const output = getFinalText(r);
-        return `## ${r.agent}\n${output}`;
-      })
-      .join('\n\n');
-  }
-
-  async function executePhase(
-    cwd: string,
-    phase: PhaseDefinition,
-    synthesis: string,
-    previousOutput: string,
+  async function confirmProjectAgentsIfNeeded(
     ctx: ExtensionCommandContext,
-    agentScope: AgentScope,
-    resolvedPaths?: ResolvedPaths,
-  ): Promise<{ results: AgentResult[]; output: string; aborted: boolean }> {
-    const task = phase.taskTemplate
-      .replace(/\{synthesis\}/g, synthesis)
-      .replace(/\{previous\}/g, previousOutput);
-
-    ctx.ui.notify(
-      `${formatPhaseHeader(phase.name, 'running')} ${phase.kind === 'parallel' ? `(${phase.agents.length} agents)` : phase.agents[0]}`,
-      'info',
+    agents: AgentConfig[],
+    projectAgentsDir: string | null,
+    confirmProjectAgents: boolean,
+  ): Promise<boolean> {
+    if (!ctx.hasUI || !confirmProjectAgents || agents.length === 0) return true;
+
+    const names = Array.from(new Set(agents.map((agent) => agent.name))).join(', ');
+    const dir = projectAgentsDir ?? '(unknown)';
+    return ctx.ui.confirm(
+      'Run project-local agents?',
+      `Agents: ${names}\nSource: ${dir}\n\nProject agents are repo-controlled. Only continue for trusted repositories.`,
     );
+  }
 
-    let results: AgentResult[];
-    if (phase.kind === 'parallel') {
-      results = await runParallel(cwd, phase.agents, task, {
-        agentScope,
-        onUpdate: (_phaseName, _agentName, _result) => {
-          // Streaming updates happen per-message
-        },
-        phaseName: phase.name,
-        resolvedPaths,
-      });
-    } else {
-      const result = await runAgent(cwd, phase.agents[0], task, {
-        agentScope,
-        phaseName: phase.name,
-        resolvedPaths,
-      });
-      results = [result];
-    }
+  function buildRunAgentTask(conversation: string, explicitTask?: string): string | undefined {
+    const trimmedConversation = conversation.trim();
+    const trimmedTask = explicitTask?.trim();
 
-    const hasError = results.some((r) => r.exitCode !== 0 || r.stopReason === 'error');
-    if (hasError) {
-      const failedAgents = results
-        .filter((r) => r.exitCode !== 0 || r.stopReason === 'error')
-        .map((r) => `${r.agent}: ${r.errorMessage || r.stderr || '(unknown error)'}`)
-        .join('\n');
+    if (trimmedTask && trimmedConversation) {
+      return `Assigned task:\n${trimmedTask}\n\nRelevant main-session context:\n${trimmedConversation}`;
+    }
 
-      ctx.ui.notify(`${formatPhaseHeader(phase.name, 'failed')}\n${failedAgents}`, 'error');
-      return { results, output: combineParallelOutputs(results), aborted: true };
+    if (trimmedTask) return trimmedTask;
+    if (trimmedConversation) {
+      return `Use the following main-session context to determine and complete the task:\n\n${trimmedConversation}`;
     }
 
-    const output = combineParallelOutputs(results);
-    ctx.ui.notify(formatPhaseHeader(phase.name, 'done'), 'info');
+    return undefined;
+  }
 
-    if (phase.requiresConfirmation && ctx.hasUI) {
-      const planText = output;
-      const proceed = await confirmPlan(ctx, planText);
-      if (!proceed) {
-        ctx.ui.notify('Delegate aborted by user after plan review.', 'warning');
-        return { results, output, aborted: true };
+  function formatRunAgentSummary(options: {
+    agent: AgentConfig;
+    agentScope: AgentScope;
+    task: string;
+    result: AgentResult;
+    forked: boolean;
+  }): string {
+    const { agent, agentScope, task, result, forked } = options;
+    const output = getFinalText(result).trim();
+    const usage = formatUsageStats(result.usage, result.model);
+    const failed = result.exitCode !== 0 || result.stopReason === 'error';
+    const status = failed ? 'failed' : 'completed';
+    const lines = [
+      '## Agent Run',
+      `- Agent: \`${agent.name}\``,
+      `- Source: ${agent.source}`,
+      `- Scope: ${agentScope}`,
+      `- Session strategy: ${agent.sessionStrategy ?? 'inline'}`,
+      `- Session handling: ${forked ? 'forked current branch at active entry' : 'inline in current session'}`,
+      `- Status: ${status}`,
+      '',
+      '## Task',
+      task,
+      '',
+      '## Output',
+      output || '_No output returned._',
+    ];
+
+    if (failed) {
+      const errorText = result.errorMessage?.trim() || result.stderr.trim();
+      if (errorText) {
+        lines.push('', '## Error', errorText);
       }
     }
 
-    return { results, output, aborted: false };
+    if (usage) {
+      lines.push('', '## Usage', usage);
+    }
+
+    return lines.join('\n');
   }
 
+  pi.registerMessageRenderer('run-agent-summary', (message, { expanded }, theme) => {
+    const details = message.details as RunAgentSummaryDetails | undefined;
+    if (!details) return new Text(typeof message.content === 'string' ? message.content : '', 0, 0);
+
+    const failed = details.exitCode !== 0 || details.stopReason === 'error';
+    const icon = failed ? theme.fg('error', '✗') : theme.fg('success', '✓');
+    const title = `${icon} ${theme.fg('toolTitle', theme.bold(details.agent))}${theme.fg('muted', ` (${details.agentSource})`)}`;
+    const modeLine = theme.fg(
+      'dim',
+      `${details.forked ? 'forked branch' : 'inline'} • ${details.agentScope} • ${details.sessionStrategy}`,
+    );
+    const usageLine = formatUsageStats(details.usage);
+    const outputPreview = details.output.trim() || '(no output)';
+
+    if (!expanded) {
+      const previewLines = outputPreview.split('\n').slice(0, 3).join('\n');
+      const text = [
+        title,
+        modeLine,
+        theme.fg('muted', `Task: ${details.task}`),
+        failed && details.errorMessage ? theme.fg('error', `Error: ${details.errorMessage}`) : previewLines,
+        usageLine ? theme.fg('dim', usageLine) : undefined,
+        theme.fg('muted', '(Ctrl+O to expand)'),
+      ]
+        .filter((line): line is string => Boolean(line))
+        .join('\n');
+      const box = new Box(1, 1, (text) => theme.bg('customMessageBg', text));
+      box.addChild(new Text(text, 0, 0));
+      return box;
+    }
+
+    const mdTheme = getMarkdownTheme();
+    const box = new Box(1, 1, (text) => theme.bg('customMessageBg', text));
+    box.addChild(new Text(title, 0, 0));
+    box.addChild(new Text(modeLine, 0, 0));
+    if (usageLine) box.addChild(new Text(theme.fg('dim', usageLine), 0, 0));
+    box.addChild(new Spacer(1));
+    box.addChild(new Text(theme.fg('muted', 'Task'), 0, 0));
+    box.addChild(new Text(theme.fg('text', details.task), 0, 0));
+    if (failed && details.errorMessage) {
+      box.addChild(new Spacer(1));
+      box.addChild(new Text(theme.fg('error', 'Error'), 0, 0));
+      box.addChild(new Text(theme.fg('error', details.errorMessage), 0, 0));
+    }
+    box.addChild(new Spacer(1));
+    box.addChild(new Text(theme.fg('muted', 'Output'), 0, 0));
+    box.addChild(new Markdown(outputPreview, 0, 0, mdTheme));
+    return box;
+  });
+
   async function listMdFiles(dir: string): Promise<Set<string>> {
     if (!existsSync(dir)) return new Set();
     try {
@@ -1233,9 +1402,55 @@ export default function (pi: ExtensionAPI) {
     }
   }
 
+  pi.on('session_start', async (_event, ctx) => {
+    autocompleteCwd = ctx.cwd;
+  });
+
   pi.registerCommand('delegate-agents', {
     description: 'List, customize, or reset delegate agents',
+    getArgumentCompletions: async (argumentText) => {
+      const userDir = join(getAgentDir(), 'agents');
+      const { completedTokens } = parseArgumentText(argumentText);
+      const action = completedTokens[0];
+
+      if (!action) {
+        return buildArgumentCompletions(argumentText, [
+          { value: 'list', description: 'Show bundled and overridden agents' },
+          { value: 'reset', description: 'Restore bundled agents by removing user overrides' },
+          { value: 'edit', description: 'Copy a bundled agent into your user agents directory' },
+        ]);
+      }
+
+      if (action === 'reset') {
+        if (completedTokens.length > 1) return null;
+        const bundled = await listMdFiles(bundledAgentsDir);
+        const user = await listMdFiles(userDir);
+        const resettable = [...user].filter((name) => bundled.has(name)).sort();
+        return buildArgumentCompletions(argumentText, [
+          { value: '--all', description: 'Reset all user overrides that have bundled versions' },
+          ...resettable.map((name) => ({
+            value: name,
+            description: 'Reset this user override to the bundled version',
+          })),
+        ]);
+      }
+
+      if (action === 'edit') {
+        if (completedTokens.length > 1) return null;
+        const bundled = [...(await listMdFiles(bundledAgentsDir))].sort();
+        return buildArgumentCompletions(
+          argumentText,
+          bundled.map((name) => ({
+            value: name,
+            description: 'Copy this bundled agent into your user agents directory',
+          })),
+        );
+      }
+
+      return null;
+    },
     handler: async (args, ctx) => {
+      autocompleteCwd = ctx.cwd;
       const userDir = join(getAgentDir(), 'agents');
       const parts = args?.trim().split(/\s+/) || [];
       const action = parts[0] || 'list';
@@ -1328,136 +1543,219 @@ export default function (pi: ExtensionAPI) {
     },
   });
 
-  pi.registerCommand('delegate', {
+  pi.registerCommand('run-agent', {
     description:
-      'Orchestrate subagent workflows — supports --scope, --workflow, and project-local agents',
+      'Run a single agent directly — honors agent sessionStrategy metadata such as fork-at',
+    getArgumentCompletions: async (argumentText) => {
+      const { completedTokens } = parseArgumentText(argumentText);
+      let agentScope: AgentScope = 'user';
+      let expectsScopeValue = false;
+      let expectsThinkingValue = false;
+      let expectsModelValue = false;
+      let agentName: string | undefined;
+
+      for (const token of completedTokens) {
+        if (expectsScopeValue) {
+          if (token === 'user' || token === 'project' || token === 'both') {
+            agentScope = token;
+          }
+          expectsScopeValue = false;
+          continue;
+        }
+        if (expectsThinkingValue) {
+          expectsThinkingValue = false;
+          continue;
+        }
+        if (expectsModelValue) {
+          expectsModelValue = false;
+          continue;
+        }
+        if (token === '--scope') {
+          expectsScopeValue = true;
+          continue;
+        }
+        if (token === '--thinking' || token === '--reasoning-level') {
+          expectsThinkingValue = true;
+          continue;
+        }
+        if (token === '--model') {
+          expectsModelValue = true;
+          continue;
+        }
+        if (token === '--yes-project-agents') continue;
+        if (token.startsWith('--')) continue;
+        if (!agentName) agentName = token;
+      }
+
+      if (expectsScopeValue) {
+        return buildArgumentCompletions(argumentText, [
+          { value: 'user', description: 'Only user/global agents from ~/.pi/agent/agents' },
+          { value: 'project', description: 'Only project-local agents from .pi/agents' },
+          { value: 'both', description: 'User/global agents plus project-local agents' },
+        ]);
+      }
+
+      if (expectsThinkingValue) {
+        return buildArgumentCompletions(argumentText, [
+          { value: 'off', description: 'Disable reasoning if the model supports it' },
+          { value: 'minimal', description: 'Minimal reasoning effort' },
+          { value: 'low', description: 'Lower reasoning effort' },
+          { value: 'medium', description: 'Balanced reasoning effort' },
+          { value: 'high', description: 'Higher reasoning effort' },
+          { value: 'xhigh', description: 'Maximum reasoning effort on supported models' },
+        ]);
+      }
+
+      if (expectsModelValue) {
+        const models = await getAutocompleteModels(agentScope);
+        return buildArgumentCompletions(argumentText, models);
+      }
+      if (agentName) return null;
+
+      const agents = await getAutocompleteAgents(agentScope);
+      return buildArgumentCompletions(argumentText, [
+        { value: '--scope', description: 'Choose which agent directories are searched' },
+        { value: '--model', description: 'Override the agent model for this run' },
+        { value: '--thinking', description: 'Override the reasoning level for this run' },
+        { value: '--reasoning-level', description: 'Alias for --thinking' },
+        { value: '--yes-project-agents', description: 'Skip the project-agent trust confirmation prompt' },
+        ...agents.map((agent) => ({
+          value: agent.name,
+          label: agent.name,
+          description: `${agent.source} — ${agent.description}`,
+        })),
+      ]);
+    },
     handler: async (args, ctx) => {
-      const parsed = parseDelegateArgs(args);
+      autocompleteCwd = ctx.cwd;
+      const parsed = parseRunAgentArgs(args);
       if (!parsed.ok) {
         ctx.ui.notify(parsed.error, 'warning');
         return;
       }
 
-      const { explicitTask, agentScope, workflowId, confirmProjectAgents } = parsed.options;
-      const resolvedPaths = await tryResolvePackagePaths(ctx.cwd);
-
-      // Step 1: Synthesize
-      const conversation = extractRecentConversation(ctx);
-      if (!conversation.trim() && !explicitTask) {
-        ctx.ui.notify(`No conversation context and no task specified.\n\n${formatDelegateUsage()}`, 'warning');
+      const { agentName, explicitTask, agentScope, confirmProjectAgents, model, thinking } = parsed.options;
+      if (!agentName) {
+        ctx.ui.notify(formatRunAgentUsage(), 'warning');
         return;
       }
 
-      const prompt = buildSynthesisPrompt(conversation, explicitTask);
-      ctx.ui.notify('⏳ Synthesizing task from conversation...', 'info');
-
-      const synthResult = await runAgent(ctx.cwd, 'planner', prompt, { agentScope, resolvedPaths });
-      const synthesis = getFinalText(synthResult);
+      const resolvedPaths = await tryResolvePackagePaths(ctx.cwd);
+      const discovery = discoverAgentsWithPackages(ctx.cwd, agentScope, resolvedPaths);
+      const agent = discovery.agents.find((candidate) => candidate.name === agentName);
 
-      if (!synthesis.trim()) {
-        ctx.ui.notify('Failed to synthesize task from conversation.', 'error');
+      if (!agent) {
+        const available = discovery.agents.map((candidate) => candidate.name).join(', ') || 'none';
+        ctx.ui.notify(`Unknown agent: "${agentName}". Available: ${available}`, 'warning');
         return;
       }
 
-      // Step 2: Confirm synthesis
-      if (ctx.hasUI) {
-        const synthOk = await confirmSynthesis(ctx, synthesis);
-        if (!synthOk) {
-          ctx.ui.notify('Delegate cancelled.', 'info');
-          return;
-        }
-      }
-
-      // Step 3: Pick workflow
-      const workflow = workflowId
-        ? getWorkflow(workflowId)
-        : ctx.hasUI
-          ? await pickWorkflow(ctx, synthesis)
-          : getWorkflow(suggestWorkflow(synthesis));
-      if (!workflow) {
-        ctx.ui.notify('Delegate cancelled — no workflow selected.', 'info');
+      const requestedProjectAgents = agent.source === 'project' ? [agent] : [];
+      const approved = await confirmProjectAgentsIfNeeded(
+        ctx,
+        requestedProjectAgents,
+        discovery.projectAgentsDir,
+        confirmProjectAgents,
+      );
+      if (!approved) {
+        ctx.ui.notify('Run cancelled — project-local agents not approved.', 'info');
         return;
       }
 
-      if ((agentScope === 'project' || agentScope === 'both') && confirmProjectAgents && ctx.hasUI) {
-        const discovery = discoverAgentsWithPackages(ctx.cwd, agentScope, resolvedPaths);
-        const requestedProjectAgents = workflow.phases
-          .flatMap((phase) => phase.agents)
-          .map((name) => discovery.agents.find((agent) => agent.name === name))
-          .filter((agent): agent is AgentConfig => agent?.source === 'project');
-
-        if (requestedProjectAgents.length > 0) {
-          const names = Array.from(new Set(requestedProjectAgents.map((agent) => agent.name))).join(', ');
-          const dir = discovery.projectAgentsDir ?? '(unknown)';
-          const ok = await ctx.ui.confirm(
-            'Run project-local agents?',
-            `Agents: ${names}\nSource: ${dir}\n\nProject agents are repo-controlled. Only continue for trusted repositories.`,
-          );
-          if (!ok) {
-            ctx.ui.notify('Delegate cancelled — project-local agents not approved.', 'info');
-            return;
-          }
-        }
+      const conversation = extractRecentConversation(ctx);
+      const task = buildRunAgentTask(conversation, explicitTask);
+      if (!task) {
+        ctx.ui.notify(`No conversation context and no task specified.\n\n${formatRunAgentUsage()}`, 'warning');
+        return;
       }
 
-      // Step 4: Execute phases
-      const state: DelegateState = {
-        synthesis,
-        workflow,
-        phases: [],
-        totalUsage: emptyDelegateUsage(),
-      };
-
-      let previousOutput = '';
-
-      ctx.ui.notify(`Starting workflow: ${workflow.label} [${agentScope}]`, 'info');
+      const runAndReport = async (
+        commandCwd: string,
+        commandUi: typeof ctx.ui,
+        sendSummary: (message: {
+          customType: 'run-agent-summary';
+          content: string;
+          display: true;
+          details: RunAgentSummaryDetails;
+        }) => Promise<void> | void,
+        forked: boolean,
+      ) => {
+        const selectedModel = model ?? agent.model;
+        const selectedThinking = thinking ?? agent.thinking;
+
+        commandUi.notify(
+          `Running agent: ${agent.name} [${agent.source}${forked ? ', forked' : ', inline'}${selectedModel ? `, model=${selectedModel}` : ''}${selectedThinking ? `, thinking=${selectedThinking}` : ''}]`,
+          'info',
+        );
 
-      for (const phaseDef of workflow.phases) {
-        const phaseResult = await executePhase(
-          ctx.cwd,
-          phaseDef,
-          synthesis,
-          previousOutput,
-          ctx,
+        const result = await runAgent(commandCwd, agent.name, task, {
           agentScope,
           resolvedPaths,
-        );
-
-        const phase: PhaseResult = {
-          name: phaseDef.name,
-          kind: phaseDef.kind,
-          agents: phaseResult.results,
-        };
+          model,
+          thinking,
+        });
+        const failed = result.exitCode !== 0 || result.stopReason === 'error';
+        const output = getFinalText(result).trim();
 
-        state.phases.push(phase);
-        const phaseUsage = aggregateUsage(phaseResult.results);
-        state.totalUsage.input += phaseUsage.input;
-        state.totalUsage.output += phaseUsage.output;
-        state.totalUsage.cacheRead += phaseUsage.cacheRead;
-        state.totalUsage.cacheWrite += phaseUsage.cacheWrite;
-        state.totalUsage.cost += phaseUsage.cost;
-        state.totalUsage.turns += phaseUsage.turns;
+        commandUi.notify(
+          failed ? `Agent "${agent.name}" failed.` : `Agent "${agent.name}" complete.`,
+          failed ? 'error' : 'info',
+        );
 
-        if (phaseResult.aborted) break;
+        await sendSummary({
+          customType: 'run-agent-summary',
+          content: formatRunAgentSummary({
+            agent,
+            agentScope,
+            task,
+            result,
+            forked,
+          }),
+          display: true,
+          details: {
+            agent: agent.name,
+            agentSource: agent.source,
+            agentScope,
+            sessionStrategy: agent.sessionStrategy ?? 'inline',
+            forked,
+            exitCode: result.exitCode,
+            stopReason: result.stopReason,
+            errorMessage: result.errorMessage,
+            usage: result.usage,
+            task,
+            output,
+          } satisfies RunAgentSummaryDetails,
+        });
+      };
 
-        previousOutput = phaseResult.output;
+      if (agent.sessionStrategy === 'fork-at') {
+        const leafId = ctx.sessionManager.getLeafId?.();
+        if (!leafId) {
+          ctx.ui.notify(
+            `Agent "${agent.name}" prefers fork-at, but the current session cannot be forked. Running inline instead.`,
+            'warning',
+          );
+        } else {
+          const forkResult = await ctx.fork(leafId, {
+            position: 'at',
+            withSession: async (replacementCtx) => {
+              await runAndReport(
+                replacementCtx.cwd,
+                replacementCtx.ui,
+                (message) => replacementCtx.sendMessage(message),
+                true,
+              );
+            },
+          });
+          if (forkResult.cancelled) {
+            ctx.ui.notify(`Run cancelled — unable to fork session for "${agent.name}".`, 'info');
+          }
+          return;
+        }
       }
 
-      // Step 5: Show full summary
-      const summary = formatFullSummary(state);
-      ctx.ui.notify(`Delegate complete — ${workflow.label}`, 'info');
-
-      pi.sendMessage({
-        customType: 'delegate-summary',
-        content: summary,
-        display: true,
-        details: {
-          workflow: workflow.id,
-          agentScope,
-          phaseCount: state.phases.length,
-          totalUsage: state.totalUsage,
-        },
-      });
+      await runAndReport(ctx.cwd, ctx.ui, (message) => pi.sendMessage(message), false);
     },
   });
+
 }