feat(workflows): add cooperative pause and resume

packages/cli/src/ui/commands/workflowsCommand.test.ts

@@ -44,16 +44,22 @@ describe('workflowsCommand', () => {
   let context: CommandContext;
   let listMock: ReturnType<typeof vi.fn>;
   let getMock: ReturnType<typeof vi.fn>;
+  let pauseMock: ReturnType<typeof vi.fn>;
+  let resumeMock: ReturnType<typeof vi.fn>;
 
   beforeEach(() => {
     listMock = vi.fn().mockReturnValue([] as WorkflowTask[]);
     getMock = vi.fn().mockReturnValue(undefined);
+    pauseMock = vi.fn().mockReturnValue(true);
+    resumeMock = vi.fn().mockReturnValue(true);
     context = createMockCommandContext({
       services: {
         config: {
           getWorkflowRunRegistry: () => ({
             list: listMock,
             get: getMock,
+            pause: pauseMock,
+            resume: resumeMock,
           }),
         },
       },
@@ -70,7 +76,7 @@ describe('workflowsCommand', () => {
     });
   });
 
-  it('lists active + recent buckets with running first', async () => {
+  it('lists active + recent buckets with active runs first', async () => {
     listMock.mockReturnValue([
       entry({
         runId: 'wf_done',
@@ -89,7 +95,7 @@ describe('workflowsCommand', () => {
     ]);
     const result = await workflowsCommand.action!(context, '');
     if (!result || result.type !== 'message') throw new Error('no result');
-    expect(result.content).toContain('Workflow runs (2 total · 1 running)');
+    expect(result.content).toContain('Workflow runs (2 total · 1 active)');
     const activeIdx = result.content.indexOf('Active');
     const recentIdx = result.content.indexOf('Recent');
     // Active section comes before Recent in the output.
@@ -102,6 +108,33 @@ describe('workflowsCommand', () => {
     expect(result.content).toContain('capitals');
   });
 
+  it('treats pausing and paused workflows as active and explains cooperative controls', async () => {
+    listMock.mockReturnValue([
+      entry({ runId: 'wf_pausing', status: 'pausing', startTime: 2 }),
+      entry({ runId: 'wf_paused', status: 'paused', startTime: 1 }),
+      entry({
+        runId: 'wf_done',
+        status: 'completed',
+        startTime: 3,
+        endTime: 4,
+      }),
+    ]);
+
+    const result = await workflowsCommand.action!(context, '');
+    if (!result || result.type !== 'message') throw new Error('no result');
+
+    expect(result.content).toContain('Workflow runs (3 total · 2 active)');
+    expect(result.content.indexOf('wf_pausing')).toBeLessThan(
+      result.content.indexOf('Recent'),
+    );
+    expect(result.content.indexOf('wf_paused')).toBeLessThan(
+      result.content.indexOf('Recent'),
+    );
+    expect(result.content).toContain('Background tasks');
+    expect(result.content).toContain('p');
+    expect(result.content).toContain('cooperative');
+  });
+
   it('omits the interactive tip in non_interactive / acp modes', async () => {
     const ctx = createMockCommandContext({
       services: {
@@ -117,6 +150,99 @@ describe('workflowsCommand', () => {
     expect(result.content).not.toMatch(/Tip:/);
   });
 
+  it('pauses a live running workflow with p <runId>', async () => {
+    getMock.mockReturnValue(entry({ runId: 'wf_running', status: 'running' }));
+
+    const result = await workflowsCommand.action!(context, 'p wf_running');
+
+    expect(pauseMock).toHaveBeenCalledWith('wf_running');
+    expect(resumeMock).not.toHaveBeenCalled();
+    expect(result).toMatchObject({
+      type: 'message',
+      messageType: 'info',
+    });
+    if (!result || result.type !== 'message') throw new Error('no result');
+    expect(result.content).toContain('Cooperative pause requested');
+  });
+
+  it('resumes a live paused workflow with p <runId>', async () => {
+    getMock.mockReturnValue(entry({ runId: 'wf_paused', status: 'paused' }));
+
+    const result = await workflowsCommand.action!(context, 'p wf_paused');
+
+    expect(resumeMock).toHaveBeenCalledWith('wf_paused');
+    expect(pauseMock).not.toHaveBeenCalled();
+    expect(result).toMatchObject({
+      type: 'message',
+      messageType: 'info',
+    });
+    if (!result || result.type !== 'message') throw new Error('no result');
+    expect(result.content).toContain('Resume requested');
+  });
+
+  it.each([
+    ['pausing', 'still pausing'],
+    ['completed', 'cannot be paused or resumed'],
+  ] as const)('rejects p for a %s workflow', async (status, message) => {
+    getMock.mockReturnValue(entry({ runId: 'wf_target', status }));
+
+    const result = await workflowsCommand.action!(context, 'p wf_target');
+
+    expect(pauseMock).not.toHaveBeenCalled();
+    expect(resumeMock).not.toHaveBeenCalled();
+    expect(result).toMatchObject({ type: 'message' });
+    if (!result || result.type !== 'message') throw new Error('no result');
+    expect(result.content).toContain(message);
+  });
+
+  it('rejects p for unknown or malformed targets without reading snapshots', async () => {
+    const unknown = await workflowsCommand.action!(context, 'p wf_missing');
+    const malformed = await workflowsCommand.action!(context, 'p');
+
+    expect(unknown).toMatchObject({
+      type: 'message',
+      messageType: 'error',
+      content: 'Unknown live workflow runId: wf_missing',
+    });
+    expect(malformed).toMatchObject({
+      type: 'message',
+      messageType: 'error',
+    });
+    expect(pauseMock).not.toHaveBeenCalled();
+    expect(resumeMock).not.toHaveBeenCalled();
+  });
+
+  it.each(['non_interactive', 'acp'] as const)(
+    'does not expose pause control in %s mode',
+    async (executionMode) => {
+      const ctx = createMockCommandContext({
+        services: {
+          config: {
+            getWorkflowRunRegistry: () => ({
+              list: listMock,
+              get: getMock,
+              pause: pauseMock,
+              resume: resumeMock,
+            }),
+          },
+        },
+        executionMode,
+      } as unknown as Parameters<typeof createMockCommandContext>[0]);
+      getMock.mockReturnValue(
+        entry({ runId: 'wf_running', status: 'running' }),
+      );
+
+      const result = await workflowsCommand.action!(ctx, 'p wf_running');
+
+      expect(result).toMatchObject({
+        type: 'message',
+        messageType: 'error',
+      });
+      expect(pauseMock).not.toHaveBeenCalled();
+      expect(resumeMock).not.toHaveBeenCalled();
+    },
+  );
+
   it('detail view: known runId returns full per-field dump', async () => {
     const detail = entry({
       runId: 'wf_target',
@@ -334,7 +460,7 @@ describe('workflowsCommand', () => {
       ]);
       const result = await workflowsCommand.action!(ctx, '');
       if (!result || result.type !== 'message') throw new Error('no result');
-      expect(result.content).toContain('Workflow runs (1 total · 0 running)');
+      expect(result.content).toContain('Workflow runs (1 total · 0 active)');
       expect(result.content).toContain('Recent');
       expect(result.content).toContain('wf_persisted');
       expect(result.content).toContain('oldrun');
@@ -355,7 +481,7 @@ describe('workflowsCommand', () => {
       const result = await workflowsCommand.action!(ctx, '');
       if (!result || result.type !== 'message') throw new Error('no result');
       // Exactly one entry total; the live entry's meta wins, disk is dropped.
-      expect(result.content).toContain('Workflow runs (1 total · 0 running)');
+      expect(result.content).toContain('Workflow runs (1 total · 0 active)');
       expect(result.content).toContain('live-name');
       expect(result.content).not.toContain('disk-name');
       expect(result.content.match(/wf_dup/g)?.length).toBe(1);

packages/cli/src/ui/commands/workflowsCommand.ts

@@ -5,7 +5,10 @@
  */
 
 import type { WorkflowTask, WorkflowSnapshot } from '@qwen-code/qwen-code-core';
-import { listWorkflowSnapshots } from '@qwen-code/qwen-code-core';
+import {
+  isActiveWorkflowStatus,
+  listWorkflowSnapshots,
+} from '@qwen-code/qwen-code-core';
 import type { SlashCommand } from './types.js';
 import { CommandKind } from './types.js';
 import { t } from '../../i18n/index.js';
@@ -152,12 +155,10 @@ function detailLines(entry: WorkflowTask, now: number): string[] {
 export const workflowsCommand: SlashCommand = {
   name: 'workflows',
   get description() {
-    return t(
-      'List active and completed workflow runs (text dump — interactive dialog opens via the footer pill)',
-    );
+    return t('List workflow runs or cooperatively pause/resume a live run');
   },
   get argumentHint() {
-    return t('[runId]');
+    return t('[runId | p <runId>]');
   },
   kind: CommandKind.BUILT_IN,
   // Same triple-mode coverage as `/tasks`: the dialog is richer in
@@ -175,11 +176,77 @@ export const workflowsCommand: SlashCommand = {
     }
     const registry = config.getWorkflowRunRegistry();
     const allEntries = registry.list();
+    const trimmedArgs = (args ?? '').trim();
+    const tokens = trimmedArgs.split(/\s+/);
+
+    if (tokens[0] === 'p') {
+      if (context.executionMode !== 'interactive') {
+        return {
+          type: 'message' as const,
+          messageType: 'error' as const,
+          content:
+            'Workflow pause controls are available only in the interactive TUI.',
+        };
+      }
+      if (tokens.length !== 2 || !tokens[1]) {
+        return {
+          type: 'message' as const,
+          messageType: 'error' as const,
+          content: 'Usage: /workflows p <runId>',
+        };
+      }
+      const runId = tokens[1];
+      const target = registry.get(runId);
+      if (!target) {
+        return {
+          type: 'message' as const,
+          messageType: 'error' as const,
+          content: `Unknown live workflow runId: ${runId}`,
+        };
+      }
+      if (target.status === 'pausing') {
+        return {
+          type: 'message' as const,
+          messageType: 'warning' as const,
+          content: `Workflow ${runId} is still pausing; wait until it reaches paused before resuming.`,
+        };
+      }
+      if (target.status === 'running') {
+        return registry.pause(runId)
+          ? {
+              type: 'message' as const,
+              messageType: 'info' as const,
+              content: `Cooperative pause requested for workflow ${runId}.`,
+            }
+          : {
+              type: 'message' as const,
+              messageType: 'error' as const,
+              content: `Workflow ${runId} could not be paused because its state changed.`,
+            };
+      }
+      if (target.status === 'paused') {
+        return registry.resume(runId)
+          ? {
+              type: 'message' as const,
+              messageType: 'info' as const,
+              content: `Resume requested for workflow ${runId}.`,
+            }
+          : {
+              type: 'message' as const,
+              messageType: 'error' as const,
+              content: `Workflow ${runId} could not be resumed because its state changed.`,
+            };
+      }
+      return {
+        type: 'message' as const,
+        messageType: 'error' as const,
+        content: `Workflow ${runId} is ${target.status} and cannot be paused or resumed.`,
+      };
+    }
 
     // Targeted detail view: `/workflows wf_abc123` opens the detail
     // dump for that run if it exists. Reject early on unknown runId so
     // the user sees a clear error instead of an empty listing.
-    const trimmedArgs = (args ?? '').trim();
     if (trimmedArgs.length > 0) {
       let target = registry.get(trimmedArgs);
       if (!target) {
@@ -223,34 +290,34 @@ export const workflowsCommand: SlashCommand = {
     }
 
     const now = Date.now();
-    // Order: running first (oldest startTime first inside the bucket so
+    // Order: active first (oldest startTime first inside the bucket so
     // long-runners stay visible), then terminal by endTime DESC. Mirrors
     // the dialog's two-bucket sort. Snapshots are always terminal, so they
     // only ever join the second bucket.
-    const running = allEntries
-      .filter((e) => e.status === 'running')
+    const active = allEntries
+      .filter((e) => isActiveWorkflowStatus(e.status))
       .sort((a, b) => a.startTime - b.startTime);
     const terminal = [
-      ...allEntries.filter((e) => e.status !== 'running'),
+      ...allEntries.filter((e) => !isActiveWorkflowStatus(e.status)),
       ...snapshotTasks,
     ].sort((a, b) => (b.endTime ?? 0) - (a.endTime ?? 0));
 
     const lines: string[] = [];
     if (context.executionMode === 'interactive') {
       lines.push(
         t(
-          'Tip: use `/workflows <runId>` for the per-run detail view (name, description, phase tree, recent logs).',
+          'Tip: use `/workflows p <runId>` or Background tasks + p to cooperatively pause/resume; use `/workflows <runId>` for details.',
         ),
         '',
       );
     }
     lines.push(
-      `Workflow runs (${running.length + terminal.length} total · ${running.length} running)`,
+      `Workflow runs (${active.length + terminal.length} total · ${active.length} active)`,
       '',
     );
-    if (running.length > 0) {
+    if (active.length > 0) {
       lines.push('Active');
-      for (const entry of running) lines.push(rowLine(entry, now));
+      for (const entry of active) lines.push(rowLine(entry, now));
       lines.push('');
     }
     if (terminal.length > 0) {