feat(workflow): show the plan before a Dynamic Workflow runs

Manual mode approved every DynamicWorkflow call outright. That policy sat
below auto- and yolo-approve, so it only ever fired in manual mode — the one
mode whose purpose is to ask was the one mode that never saw what it was
agreeing to. Removing it lets the call reach the ask, and the approval now
carries the fan-out: subagent count, task list, prompt template, worker model,
and the summed size of the prompts about to be sent.

The token figure is the real summed prompt estimate rather than a projected
total cost. A guessed multiplier in an approval dialog is worse than no number,
because the operator would be approving against a figure that could be an order
of magnitude out.

"Approve for this session" is keyed on the workflow description, so agreeing to
one small review no longer pre-approves a later 128-agent fan-out. The rule
ships with its matcher: an arg-bearing approval rule with no `matchesRule`
never matches, which would record the grant and then ignore it every time.

Also adds `/workflow save <name>`, which writes the last run out as a skill
bundle under `.pythinker-code/skills/` so a fan-out that worked can be re-run
by name. Names are validated rather than merely lowercased — `normalizeSkillName`
is not a sanitizer, and feeding it straight to `path.join` let `../../..` place
the file anywhere on disk.

Author: elkaix

.changeset/dynamic-workflow-plan-approval.md

@@ -0,0 +1,18 @@
+---
+'@pythoughts/pythinker-code-sdk': minor
+'@pythoughts/pythinker-code': minor
+---
+
+Show the plan before a Dynamic Workflow runs, and let a good one be saved as a command
+
+Manual mode used to approve every `DynamicWorkflow` call outright. That approval
+only ever fired in manual mode — auto and yolo approve earlier in the chain — so
+the one mode whose purpose is to ask was the one mode that never saw what it was
+agreeing to. A `DynamicWorkflow` call in manual mode now asks, and the approval
+carries the fan-out: how many subagents, the task list, the prompt template, the
+worker model, and the summed size of the prompts about to be sent. "Approve for
+this session" is keyed to that workflow's description rather than granting every
+future `DynamicWorkflow` call.
+
+`/workflow save <name>` writes the last run back out as a skill under
+`.pythinker-code/skills/`, so a fan-out that worked can be re-run by name.

apps/pythinker-code/src/tui/commands/dynamic-workflow.ts

@@ -1,5 +1,14 @@
-import type { PermissionMode } from '@pythoughts/pythinker-code-sdk';
+import { mkdir, writeFile } from 'node:fs/promises';
 
+import {
+  renderSavedWorkflowSkill,
+  savedWorkflowSkillDir,
+  savedWorkflowSkillName,
+  type PermissionMode,
+} from '@pythoughts/pythinker-code-sdk';
+import { join } from 'pathe';
+
+import { getDataDir } from '#/utils/paths';
 import {
   DynamicWorkflowStartPermissionPromptComponent,
   type DynamicWorkflowStartPermissionChoice,
@@ -25,6 +34,7 @@ export async function handleDynamicWorkflowCommand(host: SlashCommandHost, args:
 
   const prompt = args.trim();
   if (handleModelSubcommand(host, prompt)) return;
+  if (await handleSaveSubcommand(host, prompt)) return;
 
   const mode = dynamicWorkflowModeSubcommand(prompt);
   if (mode !== undefined) {
@@ -114,6 +124,75 @@ function withWorkerModelInstruction(prompt: string, model: string | undefined):
     : `${prompt}\n\nUse model "${model}" for the DynamicWorkflow subagents in this task.`;
 }
 
+/**
+ * `/workflow save <name>` writes the last run back out as a skill, so a fan-out
+ * that worked can be re-run by name instead of re-described.
+ *
+ * Returns true when the input was a `save` subcommand and has been handled.
+ */
+async function handleSaveSubcommand(host: SlashCommandHost, input: string): Promise<boolean> {
+  const match = /^save(?:\s+(.*))?$/iu.exec(input);
+  if (match === null) return false;
+
+  const name = match[1]?.trim() ?? '';
+  if (name.length === 0) {
+    host.showError('Usage: /workflow save <name>');
+    return true;
+  }
+
+  const args = host.state.lastDynamicWorkflowArgs;
+  if (args === undefined) {
+    host.showError('No Dynamic Workflow has run in this session yet.');
+    return true;
+  }
+
+  const description = stringArg(args, 'description');
+  if (description === undefined) {
+    host.showError('The last Dynamic Workflow has no description to save.');
+    return true;
+  }
+
+  try {
+    const dir = savedWorkflowSkillDir({
+      scope: 'project',
+      name,
+      projectRoot: host.state.appState.workDir,
+      brandHomeDir: getDataDir(),
+    });
+    await mkdir(dir, { recursive: true });
+    await writeFile(
+      join(dir, 'SKILL.md'),
+      renderSavedWorkflowSkill({
+        name: savedWorkflowSkillName(name),
+        description,
+        subagentType: stringArg(args, 'subagent_type'),
+        promptTemplate: stringArg(args, 'prompt_template'),
+        model: stringArg(args, 'model'),
+        effort: stringArg(args, 'effort'),
+        outputSchema: recordArg(args, 'output_schema'),
+      }),
+      'utf8',
+    );
+    host.refreshSlashCommandAutocomplete();
+    host.showStatus(`Saved /${savedWorkflowSkillName(name)} to ${dir}.`);
+  } catch (error) {
+    host.showError(`Failed to save workflow: ${formatErrorMessage(error)}`);
+  }
+  return true;
+}
+
+function stringArg(args: Record<string, unknown>, key: string): string | undefined {
+  const value = args[key];
+  return typeof value === 'string' && value.trim().length > 0 ? value : undefined;
+}
+
+function recordArg(args: Record<string, unknown>, key: string): Record<string, unknown> | undefined {
+  const value = args[key];
+  return typeof value === 'object' && value !== null && !Array.isArray(value)
+    ? (value as Record<string, unknown>)
+    : undefined;
+}
+
 /** Returns true when the input was a `model` subcommand and has been handled. */
 function handleModelSubcommand(host: SlashCommandHost, input: string): boolean {
   const match = /^model(?:\s+(.*))?$/iu.exec(input);

apps/pythinker-code/src/tui/commands/registry.ts

@@ -21,6 +21,7 @@ const DYNAMIC_WORKFLOW_ARG_COMPLETIONS: readonly ArgCompletionSpec[] = [
   { value: 'on', description: 'Turn Dynamic Workflow mode on' },
   { value: 'off', description: 'Turn Dynamic Workflow mode off' },
   { value: 'model', description: 'Set the model Dynamic Workflow subagents run on' },
+  { value: 'save', description: 'Save the last Dynamic Workflow as a reusable command' },
 ];
 
 const FAST_ARG_COMPLETIONS: readonly ArgCompletionSpec[] = [

apps/pythinker-code/src/tui/components/dialogs/approval-panel.ts

@@ -32,6 +32,7 @@ import type {
   DisplayBlock,
   FileContentDisplayBlock,
   PendingApproval,
+  WorkflowPlanDisplayBlock,
 } from '#/tui/reverse-rpc/types';
 import { printableChar } from '#/tui/utils/printable-key';
 
@@ -167,6 +168,8 @@ function renderDisplayBlock(
       }
       return lines;
     }
+    case 'workflow_plan':
+      return renderWorkflowPlanDisplayBlock(block, s);
     case 'brief':
       return block.text
         ? block.text.split('\n').map((line) => (line.length > 0 ? s.strong(line) : ''))
@@ -182,6 +185,41 @@ function renderDisplayBlock(
   }
 }
 
+/**
+ * A workflow can carry up to 128 items. Listing all of them would push the
+ * buttons off the screen, so the panel shows enough to judge the shape of the
+ * fan-out and says how many it held back.
+ */
+const MAX_PREVIEW_ITEMS = 10;
+
+function renderWorkflowPlanDisplayBlock(
+  block: WorkflowPlanDisplayBlock,
+  s: BlockStyles,
+): string[] {
+  const plural = block.agent_count === 1 ? 'subagent' : 'subagents';
+  const summary = [
+    `${String(block.agent_count)} ${plural}`,
+    `~${String(block.prompt_tokens)} prompt tokens`,
+  ];
+  if (block.model !== undefined && block.model.length > 0) {
+    summary.push(`model: ${block.model}`);
+  }
+  const lines = [s.strong(summary.join('  '))];
+
+  if (block.prompt_template !== undefined && block.prompt_template.length > 0) {
+    lines.push(`${s.accent('prompt')} ${s.dim(truncateOneLine(block.prompt_template, 200))}`);
+  }
+
+  for (const [index, item] of block.items.slice(0, MAX_PREVIEW_ITEMS).entries()) {
+    lines.push(s.dim(`${String(index + 1).padStart(3)}. ${truncateOneLine(item, 120)}`));
+  }
+  const hidden = block.items.length - MAX_PREVIEW_ITEMS;
+  if (hidden > 0) {
+    lines.push(s.dim(`     +${String(hidden)} more`));
+  }
+  return lines;
+}
+
 function normalizeApprovalText(text: string): string {
   return text.replaceAll('\r\n', '\n').trim();
 }
@@ -209,6 +247,8 @@ function headerFor(toolName: string): string {
       return 'Stop this task?';
     case 'ExitPlanMode':
       return 'Ready to build with this plan?';
+    case 'DynamicWorkflow':
+      return 'Run this Dynamic Workflow?';
     default:
       return `Approve ${toolName}?`;
   }

apps/pythinker-code/src/tui/controllers/subagent-event-handler.ts

@@ -633,6 +633,8 @@ export class SubAgentEventHandler {
     args: Record<string, unknown>,
     options: { readonly streamingArguments?: string } = {},
   ): DynamicWorkflowMissionControlComponent {
+    // Kept so `/workflow save` can name a run the user just watched succeed.
+    this.host.state.lastDynamicWorkflowArgs = args;
     const existing = this.dynamicWorkflowMissionControls.get(toolCallId);
     if (existing !== undefined) {
       existing.updateArgs(args, options);

apps/pythinker-code/src/tui/reverse-rpc/approval/adapter.ts

@@ -300,15 +300,27 @@ function adaptDisplay(display: ToolInputDisplay): DisplayBlock[] {
           scope: display.scope,
         },
       ];
-    case 'agent_call':
-      return [
+    case 'agent_call': {
+      const blocks: DisplayBlock[] = [
         {
           type: 'invocation',
           kind: 'agent',
           name: display.agent_name ?? '',
           description: display.prompt,
         },
       ];
+      if (display.workflow !== undefined) {
+        blocks.push({
+          type: 'workflow_plan',
+          agent_count: display.workflow.agent_count,
+          items: [...display.workflow.items],
+          prompt_tokens: display.workflow.prompt_tokens,
+          prompt_template: display.workflow.prompt_template,
+          model: display.workflow.model,
+        });
+      }
+      return blocks;
+    }
     case 'skill_call':
       return [
         {

apps/pythinker-code/src/tui/reverse-rpc/types.ts

@@ -68,6 +68,19 @@ export interface InvocationDisplayBlock {
   description?: string | undefined;
 }
 
+/**
+ * The fan-out a Dynamic Workflow is about to launch. Shown at approval time so
+ * the decision is made against the actual task list rather than a count.
+ */
+export interface WorkflowPlanDisplayBlock {
+  type: 'workflow_plan';
+  agent_count: number;
+  items: string[];
+  prompt_tokens: number;
+  prompt_template?: string;
+  model?: string;
+}
+
 export interface TodoDisplayItem {
   title: string;
   status: 'pending' | 'in_progress' | 'done';
@@ -95,6 +108,7 @@ export type DisplayBlock =
   | UrlFetchDisplayBlock
   | SearchDisplayBlock
   | InvocationDisplayBlock
+  | WorkflowPlanDisplayBlock
   | TodoDisplayBlock
   | BackgroundTaskDisplayBlock;
 

apps/pythinker-code/src/tui/tui-state.ts

@@ -63,6 +63,12 @@ export interface TUIState {
   externalEditorRunning: boolean;
   queuedMessages: QueuedMessage[];
   dynamicWorkflowModeEntry: 'manual' | 'task' | undefined;
+  /**
+   * Arguments of the most recent DynamicWorkflow tool call, so `/workflow save`
+   * can turn a run that just worked into a reusable command. Overwritten as the
+   * call streams in; the last write is the complete one.
+   */
+  lastDynamicWorkflowArgs: Record<string, unknown> | undefined;
 }
 
 export function createTUIState(options: PythinkerTUIOptions): TUIState {
@@ -143,5 +149,6 @@ export function createTUIState(options: PythinkerTUIOptions): TUIState {
     externalEditorRunning: false,
     queuedMessages: [],
     dynamicWorkflowModeEntry: undefined,
+    lastDynamicWorkflowArgs: undefined,
   };
 }

apps/pythinker-code/test/tui/commands/dynamic-workflow.test.ts

@@ -1,3 +1,7 @@
+import { promises as fs } from 'node:fs';
+import { tmpdir } from 'node:os';
+
+import { join } from 'pathe';
 import { describe, expect, it, vi } from 'vitest';
 
 import { handleDynamicWorkflowCommand } from '#/tui/commands/index';
@@ -24,6 +28,8 @@ function makeHost(
     permissionMode?: 'manual' | 'auto' | 'yolo';
     dynamicWorkflowMode?: boolean;
     availableModels?: Record<string, unknown>;
+    workDir?: string;
+    lastDynamicWorkflowArgs?: Record<string, unknown>;
   } = {},
 ) {
   const session = {
@@ -40,10 +46,12 @@ function makeHost(
         availableModels: overrides.availableModels ?? {
           'deepseek-v4': { provider: 'deepseek', model: 'deepseek-v4' },
         },
+        workDir: overrides.workDir ?? '/workspace',
       },
       theme: currentTheme,
       transcriptContainer: { addChild: vi.fn() },
       ui: { requestRender: vi.fn() },
+      lastDynamicWorkflowArgs: overrides.lastDynamicWorkflowArgs,
     },
     session: hasSession ? session : undefined,
     requireSession: () => session,
@@ -54,6 +62,7 @@ function makeHost(
     restoreEditor: vi.fn(),
     restoreInputText: vi.fn(),
     sendNormalUserInput: vi.fn(),
+    refreshSlashCommandAutocomplete: vi.fn(),
   } as unknown as SlashCommandHost;
   return { host, session };
 }
@@ -410,3 +419,76 @@ describe('handleDynamicWorkflowCommand', () => {
     );
   });
 });
+
+describe('/workflow save', () => {
+  it('writes the last run as a skill and refreshes the command list', async () => {
+    const workDir = await fs.mkdtemp(join(tmpdir(), 'workflow-save-'));
+    try {
+      const { host } = makeHost({
+        permissionMode: 'auto',
+        workDir,
+        lastDynamicWorkflowArgs: {
+          description: 'Audit routes for missing auth',
+          subagent_type: 'reviewer',
+          prompt_template: 'Audit {{item}}',
+          model: 'deepseek-v4',
+          items: ['a.ts', 'b.ts'],
+        },
+      });
+
+      await handleDynamicWorkflowCommand(host, 'save Audit Routes');
+
+      const saved = await fs.readFile(
+        join(workDir, '.pythinker-code', 'skills', 'audit-routes', 'SKILL.md'),
+        'utf8',
+      );
+      expect(saved).toContain('name: "audit-routes"');
+      expect(saved).toContain('description: "Audit routes for missing auth"');
+      expect(saved).toContain('subagent-type: "reviewer"');
+      expect(saved).toContain('Audit {{item}}');
+      expect(host.refreshSlashCommandAutocomplete).toHaveBeenCalled();
+      expect(host.showError).not.toHaveBeenCalled();
+    } finally {
+      await fs.rm(workDir, { recursive: true, force: true });
+    }
+  });
+
+  it('refuses a name that would escape the project skills directory', async () => {
+    const workDir = await fs.mkdtemp(join(tmpdir(), 'workflow-save-'));
+    try {
+      const { host } = makeHost({
+        permissionMode: 'auto',
+        workDir,
+        lastDynamicWorkflowArgs: { description: 'Audit routes' },
+      });
+
+      await handleDynamicWorkflowCommand(host, 'save ../../../../tmp/pwned');
+
+      expect(host.showError).toHaveBeenCalledWith(
+        expect.stringContaining('not a valid skill name'),
+      );
+      expect(host.refreshSlashCommandAutocomplete).not.toHaveBeenCalled();
+      await expect(fs.stat(join(workDir, '.pythinker-code'))).rejects.toThrow(/ENOENT/);
+    } finally {
+      await fs.rm(workDir, { recursive: true, force: true });
+    }
+  });
+
+  it('explains itself when no workflow has run yet', async () => {
+    const { host } = makeHost({ permissionMode: 'auto' });
+
+    await handleDynamicWorkflowCommand(host, 'save nightly-audit');
+
+    expect(host.showError).toHaveBeenCalledWith(
+      'No Dynamic Workflow has run in this session yet.',
+    );
+  });
+
+  it('asks for a name when given none', async () => {
+    const { host } = makeHost({ permissionMode: 'auto' });
+
+    await handleDynamicWorkflowCommand(host, 'save');
+
+    expect(host.showError).toHaveBeenCalledWith('Usage: /workflow save <name>');
+  });
+});