agentic-orchestrator 0.1.6 → 0.1.8

package/apps/control-plane/test/cleanup-command.spec.ts

@@ -52,15 +52,19 @@ describe('CleanupCommandHandler', () => {
     vi.spyOn(fs, 'readdir').mockRejectedValue(new Error('no dir'));
 
     const callMock = vi.fn();
-    const handler = new CleanupCommandHandler(makeToolClient(callMock) as never, 'run:test', '/repo');
+    const handler = new CleanupCommandHandler(
+      makeToolClient(callMock) as never,
+      'run:test',
+      '/repo',
+    );
     const result = await handler.execute({ command: 'cleanup', dry_run: true });
 
     expect(result).toMatchObject({
       ok: true,
       data: {
         would_clean: [{ feature_id: 'feature_a', reason: 'terminal status: merged' }],
-        cleaned: []
-      }
+        cleaned: [],
+      },
     });
     expect(callMock).not.toHaveBeenCalled();
   });
@@ -81,20 +85,24 @@ describe('CleanupCommandHandler', () => {
     vi.spyOn(fs, 'readdir').mockRejectedValue(new Error('no dir'));
 
     const callMock = vi.fn(async () => ({ ok: true, data: {} }));
-    const handler = new CleanupCommandHandler(makeToolClient(callMock) as never, 'run:test', '/repo');
+    const handler = new CleanupCommandHandler(
+      makeToolClient(callMock) as never,
+      'run:test',
+      '/repo',
+    );
     const result = await handler.execute({ command: 'cleanup', yes: true });
 
     expect(result).toMatchObject({
       ok: true,
       data: {
         would_clean: [{ feature_id: 'feature_a' }],
-        cleaned: [{ feature_id: 'feature_a' }]
-      }
+        cleaned: [{ feature_id: 'feature_a' }],
+      },
     });
     expect(callMock).toHaveBeenCalledWith(
       TOOLS.FEATURE_DELETE,
       expect.objectContaining({ feature_id: 'feature_a', confirm: true, dry_run: false }),
-      expect.any(Object)
+      expect.any(Object),
     );
   });
 
@@ -112,19 +120,23 @@ describe('CleanupCommandHandler', () => {
     vi.spyOn(fs, 'readdir').mockResolvedValue([
       { name: 'orphan_feature', isDirectory: () => true },
       { name: 'feature_a', isDirectory: () => true },
-      { name: 'not_a_dir.txt', isDirectory: () => false }
+      { name: 'not_a_dir.txt', isDirectory: () => false },
     ] as never);
 
     const callMock = vi.fn();
-    const handler = new CleanupCommandHandler(makeToolClient(callMock) as never, 'run:test', '/repo');
+    const handler = new CleanupCommandHandler(
+      makeToolClient(callMock) as never,
+      'run:test',
+      '/repo',
+    );
     const result = await handler.execute({ command: 'cleanup', dry_run: true });
 
     expect(result).toMatchObject({
       ok: true,
       data: {
         would_clean: [{ feature_id: 'orphan_feature', reason: 'orphan worktree' }],
-        cleaned: []
-      }
+        cleaned: [],
+      },
     });
     expect(callMock).not.toHaveBeenCalled();
   });
@@ -145,7 +157,11 @@ describe('CleanupCommandHandler', () => {
     vi.spyOn(fs, 'readdir').mockRejectedValue(new Error('no dir'));
 
     const callMock = vi.fn().mockRejectedValue(new Error('delete failed'));
-    const handler = new CleanupCommandHandler(makeToolClient(callMock) as never, 'run:test', '/repo');
+    const handler = new CleanupCommandHandler(
+      makeToolClient(callMock) as never,
+      'run:test',
+      '/repo',
+    );
     const result = await handler.execute({ command: 'cleanup', yes: true });
 
     expect(result).toMatchObject({
@@ -153,8 +169,8 @@ describe('CleanupCommandHandler', () => {
       data: {
         would_clean: [{ feature_id: 'feature_a' }],
         cleaned: [],
-        skipped: [{ feature_id: 'feature_a' }]
-      }
+        skipped: [{ feature_id: 'feature_a' }],
+      },
     });
   });
 
@@ -173,23 +189,35 @@ describe('CleanupCommandHandler', () => {
     });
     vi.spyOn(fs, 'readdir').mockRejectedValue(new Error('no dir'));
 
-    const defaultHandler = new CleanupCommandHandler(makeToolClient() as never, 'run:test', '/repo', 3600, false);
+    const defaultHandler = new CleanupCommandHandler(
+      makeToolClient() as never,
+      'run:test',
+      '/repo',
+      3600,
+      false,
+    );
     const defaultResult = await defaultHandler.execute({ command: 'cleanup', dry_run: true });
     expect(defaultResult).toMatchObject({
       ok: true,
       data: {
-        would_clean: []
-      }
+        would_clean: [],
+      },
     });
 
-    const autoHandler = new CleanupCommandHandler(makeToolClient() as never, 'run:test', '/repo', 3600, true);
+    const autoHandler = new CleanupCommandHandler(
+      makeToolClient() as never,
+      'run:test',
+      '/repo',
+      3600,
+      true,
+    );
     const autoResult = await autoHandler.execute({ command: 'cleanup', dry_run: true });
     expect(autoResult).toMatchObject({
       ok: true,
       data: {
         would_clean: [{ feature_id: 'feature_merged', reason: 'terminal status: merged' }],
-        cleaned: []
-      }
+        cleaned: [],
+      },
     });
   });
 });
@@ -219,14 +247,20 @@ describe('CleanupCommandHandler branch coverage', () => {
     // Allow readdir to succeed with empty array so isRunLeaseInactive checks candidate paths
     vi.spyOn(fs, 'readdir').mockResolvedValue([]);
 
-    const handler = new CleanupCommandHandler(makeToolClient() as never, 'run:test', '/repo', 3600, false);
+    const handler = new CleanupCommandHandler(
+      makeToolClient() as never,
+      'run:test',
+      '/repo',
+      3600,
+      false,
+    );
     const result = await handler.execute({ command: 'cleanup', dry_run: true });
     expect(result).toMatchObject({
       ok: true,
       data: {
         would_clean: [],
-        skipped: [{ feature_id: 'feature_active_lease', reason: 'run lease still active' }]
-      }
+        skipped: [{ feature_id: 'feature_active_lease', reason: 'run lease still active' }],
+      },
     });
   });
 
@@ -245,14 +279,20 @@ describe('CleanupCommandHandler branch coverage', () => {
     });
     vi.spyOn(fs, 'readdir').mockRejectedValue(new Error('no dir'));
 
-    const handler = new CleanupCommandHandler(makeToolClient() as never, 'run:test', '/repo', 3600, false);
+    const handler = new CleanupCommandHandler(
+      makeToolClient() as never,
+      'run:test',
+      '/repo',
+      3600,
+      false,
+    );
     const result = await handler.execute({ command: 'cleanup', dry_run: true });
     expect(result).toMatchObject({
       ok: true,
       data: {
         would_clean: [],
-        skipped: [{ feature_id: 'feature_grace_period', reason: 'not eligible' }]
-      }
+        skipped: [{ feature_id: 'feature_grace_period', reason: 'not eligible' }],
+      },
     });
   });
 
@@ -266,13 +306,21 @@ describe('CleanupCommandHandler branch coverage', () => {
     });
     vi.spyOn(fs, 'readdir').mockRejectedValue(new Error('no dir'));
 
-    const handler = new CleanupCommandHandler(makeToolClient() as never, 'run:test', '/repo', 3600, true);
+    const handler = new CleanupCommandHandler(
+      makeToolClient() as never,
+      'run:test',
+      '/repo',
+      3600,
+      true,
+    );
     const result = await handler.execute({ command: 'cleanup', dry_run: true });
     expect(result).toMatchObject({
       ok: true,
       data: {
-        would_clean: [{ feature_id: 'feature_no_state', reason: 'merged residue with missing state' }]
-      }
+        would_clean: [
+          { feature_id: 'feature_no_state', reason: 'merged residue with missing state' },
+        ],
+      },
     });
   });
 });
@@ -288,14 +336,20 @@ describe('CleanupCommandHandler state unreadable branch', () => {
     });
     vi.spyOn(fs, 'readdir').mockRejectedValue(new Error('no dir'));
 
-    const handler = new CleanupCommandHandler(makeToolClient() as never, 'run:test', '/repo', 3600, false);
+    const handler = new CleanupCommandHandler(
+      makeToolClient() as never,
+      'run:test',
+      '/repo',
+      3600,
+      false,
+    );
     const result = await handler.execute({ command: 'cleanup', dry_run: true });
     expect(result).toMatchObject({
       ok: true,
       data: {
         would_clean: [],
-        skipped: [{ feature_id: 'feature_bad_state', reason: 'state unreadable' }]
-      }
+        skipped: [{ feature_id: 'feature_bad_state', reason: 'state unreadable' }],
+      },
     });
   });
 });

package/apps/control-plane/test/cli-helpers.spec.ts

@@ -4,7 +4,11 @@ import { ERROR_CODES } from '../src/core/error-codes.js';
 import { TOOLS } from '../src/core/constants.js';
 import { CliArgumentParser } from '../src/cli/cli-argument-parser.js';
 import { assertOkResponse, callCliTool } from '../src/cli/tooling.js';
-import { canonicalFeatureIdFromPath, isCanonicalSpecPath, isLegacyCanonicalSpecPath } from '../src/cli/spec-utils.js';
+import {
+  canonicalFeatureIdFromPath,
+  isCanonicalSpecPath,
+  isLegacyCanonicalSpecPath,
+} from '../src/cli/spec-utils.js';
 import { RetryCommandHandler } from '../src/cli/retry-command-handler.js';
 import { StatusCommandHandler } from '../src/cli/status-command-handler.js';
 import { SendCommandHandler } from '../src/cli/send-command-handler.js';
@@ -29,7 +33,7 @@ describe('cli helper modules', () => {
       '--batch',
       '--takeover-stale-run',
       '--message',
-      'hello world'
+      'hello world',
     ]);
     expect(miscParsed).toMatchObject({
       command: 'status',
@@ -43,7 +47,7 @@ describe('cli helper modules', () => {
       auto: true,
       batch: true,
       takeover_stale_run: true,
-      message: 'hello world'
+      message: 'hello world',
     });
     // --port with non-numeric next token (no value consumed)
     const portNoNum = parser.parse(['run', '--port', '--foreground']);
@@ -51,7 +55,7 @@ describe('cli helper modules', () => {
     expect(portNoNum.foreground).toBe(true);
     expect(parser.parse(['-fi', '.aop/features/feature_x/spec.md'])).toMatchObject({
       command: 'run',
-      file_input: '.aop/features/feature_x/spec.md'
+      file_input: '.aop/features/feature_x/spec.md',
     });
 
     const parsed = parser.parse([
@@ -63,7 +67,7 @@ describe('cli helper modules', () => {
       '--provider-config-env',
       'AOP_PROVIDER_CFG',
       '--transport',
-      'mcp'
+      'mcp',
     ]);
 
     expect(parsed).toMatchObject({
@@ -71,7 +75,7 @@ describe('cli helper modules', () => {
       agent_model: 'gpt-5',
       agent_config: '{"command":"kiro-cli","args":["chat","--agent","dev"]}',
       provider_config_env: 'AOP_PROVIDER_CFG',
-      transport: 'mcp'
+      transport: 'mcp',
     });
     const deleteParsed = parser.parse([
       'delete',
@@ -83,7 +87,7 @@ describe('cli helper modules', () => {
       '--remove-worktree',
       'false',
       '--remove-branch',
-      'force'
+      'force',
     ]);
     expect(deleteParsed).toMatchObject({
       command: 'delete',
@@ -91,18 +95,22 @@ describe('cli helper modules', () => {
       yes: true,
       dry_run: false,
       remove_worktree: false,
-      remove_branch: 'force'
+      remove_branch: 'force',
     });
-    const positionalSend = parser.parse(['send', 'feature_positional', 'please rerun qa with latest fixes']);
+    const positionalSend = parser.parse([
+      'send',
+      'feature_positional',
+      'please rerun qa with latest fixes',
+    ]);
     expect(positionalSend).toMatchObject({
       command: 'send',
       feature_id: 'feature_positional',
-      message: 'please rerun qa with latest fixes'
+      message: 'please rerun qa with latest fixes',
     });
     const positionalAttach = parser.parse(['attach', 'feature_positional']);
     expect(positionalAttach).toMatchObject({
       command: 'attach',
-      feature_id: 'feature_positional'
+      feature_id: 'feature_positional',
     });
     expect(parser.resolveTransport('InProcess')).toBe('inprocess');
     expect(parser.resolveTransport(undefined)).toBe('mcp');
@@ -111,16 +119,24 @@ describe('cli helper modules', () => {
   it('GIVEN_noncanonical_paths_WHEN_deriving_feature_id_or_canonical_spec_THEN_throws_or_returns_null', () => {
     expect(canonicalFeatureIdFromPath('feature_x.spec.md')).toBe('feature_x');
     expect(canonicalFeatureIdFromPath('feature_x-spec.md')).toBe('feature_x');
-    expect(() => canonicalFeatureIdFromPath('INVALID Feature.md')).toThrow(ERROR_CODES.INVALID_FEATURE_SLUG);
+    expect(() => canonicalFeatureIdFromPath('INVALID Feature.md')).toThrow(
+      ERROR_CODES.INVALID_FEATURE_SLUG,
+    );
 
     expect(
-      isCanonicalSpecPath('/repo', path.join('/repo', '.aop', 'features', 'feature_a', 'spec.md'))
+      isCanonicalSpecPath('/repo', path.join('/repo', '.aop', 'features', 'feature_a', 'spec.md')),
     ).toBe('feature_a');
     expect(
-      isLegacyCanonicalSpecPath('/repo', path.join('/repo', 'agentic', 'features', 'feature_a', 'spec.md'))
+      isLegacyCanonicalSpecPath(
+        '/repo',
+        path.join('/repo', 'agentic', 'features', 'feature_a', 'spec.md'),
+      ),
     ).toBe('feature_a');
     expect(
-      isCanonicalSpecPath('/repo', path.join('/repo', 'agentic', 'features', 'feature_a', 'spec.md'))
+      isCanonicalSpecPath(
+        '/repo',
+        path.join('/repo', 'agentic', 'features', 'feature_a', 'spec.md'),
+      ),
     ).toBeNull();
     expect(isCanonicalSpecPath('/repo', '/repo/spec-files/feature_a.md')).toBeNull();
   });
@@ -129,17 +145,19 @@ describe('cli helper modules', () => {
     expect(() =>
       assertOkResponse({
         ok: false,
-        error: {}
-      } as any)
+        error: {},
+      } as any),
     ).toThrow(ERROR_CODES.INTERNAL_ERROR);
   });
 
   it('GIVEN_tool_client_response_WHEN_calling_cli_tool_THEN_uses_system_identity_and_returns_ok_payload', async () => {
     const toolClient = {
-      call: vi.fn(async () => ({ ok: true, data: { accepted: true } }))
+      call: vi.fn(async () => ({ ok: true, data: { accepted: true } })),
     };
 
-    const response = await callCliTool(toolClient as any, 'run:cli', 'report.dashboard', { sample: true });
+    const response = await callCliTool(toolClient as any, 'run:cli', 'report.dashboard', {
+      sample: true,
+    });
 
     expect(response).toMatchObject({ ok: true, data: { accepted: true } });
     expect(toolClient.call).toHaveBeenCalledWith(
@@ -149,8 +167,8 @@ describe('cli helper modules', () => {
         run_id: 'run:cli',
         session_id: 'bootstrap:cli',
         actor_type: 'system',
-        actor_id: 'cli:system'
-      })
+        actor_id: 'cli:system',
+      }),
     );
   });
 });
@@ -164,7 +182,7 @@ describe('RetryCommandHandler', () => {
     const toolClient = { call: vi.fn() };
     const handler = new RetryCommandHandler(toolClient as never, 'run:test');
     await expect(handler.execute({ command: 'retry' })).rejects.toMatchObject({
-      code: ERROR_CODES.INVALID_CLI_ARGS
+      code: ERROR_CODES.INVALID_CLI_ARGS,
     });
   });
 
@@ -172,7 +190,7 @@ describe('RetryCommandHandler', () => {
     const toolClient = { call: vi.fn() };
     const handler = new RetryCommandHandler(toolClient as never, 'run:test');
     await expect(
-      handler.execute({ command: 'retry', feature_id: 'INVALID Feature ID' })
+      handler.execute({ command: 'retry', feature_id: 'INVALID Feature ID' }),
     ).rejects.toMatchObject({ code: ERROR_CODES.INVALID_CLI_ARGS });
   });
 
@@ -195,13 +213,13 @@ describe('RetryCommandHandler', () => {
         retry_count_reset: false,
         retry_executed: true,
         retry_mode: 'full',
-        retry_outcome: 'pass'
-      }
+        retry_outcome: 'pass',
+      },
     });
     expect(callMock).toHaveBeenCalledWith(
       TOOLS.GATES_RUN,
       expect.objectContaining({ feature_id: 'feature_abc', mode: 'full' }),
-      expect.any(Object)
+      expect.any(Object),
     );
   });
 
@@ -216,26 +234,30 @@ describe('RetryCommandHandler', () => {
       return { ok: true, data: {} };
     });
     const handler = new RetryCommandHandler({ call: callMock } as never, 'run:test');
-    const result = await handler.execute({ command: 'retry', feature_id: 'feature_abc', force: true });
+    const result = await handler.execute({
+      command: 'retry',
+      feature_id: 'feature_abc',
+      force: true,
+    });
 
     expect(result).toMatchObject({
       ok: true,
-      data: { feature_id: 'feature_abc', retry_count_reset: true }
+      data: { feature_id: 'feature_abc', retry_count_reset: true },
     });
     expect(callMock).toHaveBeenCalledWith(
       TOOLS.FEATURE_STATE_GET,
       expect.objectContaining({ feature_id: 'feature_abc' }),
-      expect.any(Object)
+      expect.any(Object),
     );
     expect(callMock).toHaveBeenCalledWith(
       TOOLS.FEATURE_STATE_PATCH,
       expect.objectContaining({ feature_id: 'feature_abc', expected_version: 5 }),
-      expect.any(Object)
+      expect.any(Object),
     );
     expect(callMock).toHaveBeenCalledWith(
       TOOLS.GATES_RUN,
       expect.objectContaining({ feature_id: 'feature_abc' }),
-      expect.any(Object)
+      expect.any(Object),
     );
   });
 });
@@ -260,7 +282,7 @@ describe('StatusCommandHandler', () => {
     const features = [
       { feature_id: 'no_ts', status: 'planning' },
       { feature_id: 'recent', status: 'building', last_heartbeat_at: recentTs },
-      { feature_id: 'old_one', status: 'merged', last_run_at: oldTs }
+      { feature_id: 'old_one', status: 'merged', last_run_at: oldTs },
     ];
     const toolClient = { call: vi.fn(async () => ({ ok: true, data: { features } })) };
     const handler = new StatusCommandHandler(toolClient as never, 'run:test');
@@ -272,9 +294,9 @@ describe('StatusCommandHandler', () => {
         summary: [
           { feature_id: 'no_ts', status: 'planning', activity: 'unknown' },
           { feature_id: 'recent', status: 'building', activity: 'active' },
-          { feature_id: 'old_one', status: 'merged', activity: 'idle' }
-        ]
-      }
+          { feature_id: 'old_one', status: 'merged', activity: 'idle' },
+        ],
+      },
     });
   });
 
@@ -287,7 +309,7 @@ describe('StatusCommandHandler', () => {
       merge_ready: true,
       pending_review_threads: 0,
       has_conflicts: false,
-      merge_score: 100
+      merge_score: 100,
     };
     const features = [{ feature_id: 'feature_a', status: 'review', pr: prData }];
     const toolClient = { call: vi.fn(async () => ({ ok: true, data: { features } })) };
@@ -297,8 +319,8 @@ describe('StatusCommandHandler', () => {
     expect(result).toMatchObject({
       ok: true,
       data: {
-        features: [expect.objectContaining({ feature_id: 'feature_a', pr_info: prData })]
-      }
+        features: [expect.objectContaining({ feature_id: 'feature_a', pr_info: prData })],
+      },
     });
   });
 
@@ -318,7 +340,7 @@ describe('SendCommandHandler', () => {
     const toolClient = { call: vi.fn() };
     const handler = new SendCommandHandler(toolClient as never, 'run:test');
     await expect(
-      handler.execute({ command: 'send', feature_id: 'INVALID Feature ID', message: 'hello' })
+      handler.execute({ command: 'send', feature_id: 'INVALID Feature ID', message: 'hello' }),
     ).rejects.toMatchObject({ code: ERROR_CODES.INVALID_CLI_ARGS });
   });
 });
@@ -333,14 +355,19 @@ describe('RetryCommandHandler branch coverage', () => {
     });
     const handler = new RetryCommandHandler({ call: callMock } as never, 'run:test');
     await expect(
-      handler.execute({ command: 'retry', feature_id: 'feature_x' })
+      handler.execute({ command: 'retry', feature_id: 'feature_x' }),
     ).rejects.toMatchObject({ code: ERROR_CODES.INVALID_CLI_ARGS });
   });
 
   it('GIVEN_feature_blocked_with_forced_retry_fast_reason_WHEN_execute_called_THEN_infers_fast_mode', async () => {
     const callMock = vi.fn().mockImplementation(async (toolName: string) => {
       if (toolName === TOOLS.FEATURE_STATE_GET) {
-        return { ok: true, data: { front_matter: { version: 2, status: 'blocked', status_reason: 'forced_retry:fast' } } };
+        return {
+          ok: true,
+          data: {
+            front_matter: { version: 2, status: 'blocked', status_reason: 'forced_retry:fast' },
+          },
+        };
       }
       if (toolName === TOOLS.GATES_RUN) {
         return { ok: true, data: { overall: 'pass' } };
@@ -348,7 +375,11 @@ describe('RetryCommandHandler branch coverage', () => {
       return { ok: true, data: {} };
     });
     const handler = new RetryCommandHandler({ call: callMock } as never, 'run:test');
-    const result = await handler.execute({ command: 'retry', feature_id: 'feature_y', force: true }) as Record<string, unknown>;
+    const result = (await handler.execute({
+      command: 'retry',
+      feature_id: 'feature_y',
+      force: true,
+    })) as Record<string, unknown>;
     const data = result.data as Record<string, unknown>;
     expect(data.retry_mode).toBe('fast');
   });
@@ -356,7 +387,12 @@ describe('RetryCommandHandler branch coverage', () => {
   it('GIVEN_feature_blocked_with_force_and_last_gate_mode_full_WHEN_execute_called_THEN_patches_status_to_qa', async () => {
     const callMock = vi.fn().mockImplementation(async (toolName: string) => {
       if (toolName === TOOLS.FEATURE_STATE_GET) {
-        return { ok: true, data: { front_matter: { version: 3, status: 'blocked', evidence: { last_gate_mode: 'full' } } } };
+        return {
+          ok: true,
+          data: {
+            front_matter: { version: 3, status: 'blocked', evidence: { last_gate_mode: 'full' } },
+          },
+        };
       }
       if (toolName === TOOLS.GATES_RUN) {
         return { ok: true, data: { overall: 'pass' } };
@@ -364,22 +400,33 @@ describe('RetryCommandHandler branch coverage', () => {
       return { ok: true, data: {} };
     });
     const handler = new RetryCommandHandler({ call: callMock } as never, 'run:test');
-    const result = await handler.execute({ command: 'retry', feature_id: 'feature_z', force: true }) as Record<string, unknown>;
+    const result = (await handler.execute({
+      command: 'retry',
+      feature_id: 'feature_z',
+      force: true,
+    })) as Record<string, unknown>;
     const data = result.data as Record<string, unknown>;
     expect(data.retry_mode).toBe('full');
     expect(data.forced_retry_executed).toBe(true);
     // verify patch was called with status qa
     expect(callMock).toHaveBeenCalledWith(
       TOOLS.FEATURE_STATE_PATCH,
-      expect.objectContaining({ patch: expect.objectContaining({ front_matter: expect.objectContaining({ status: 'qa' }) }) }),
-      expect.any(Object)
+      expect.objectContaining({
+        patch: expect.objectContaining({ front_matter: expect.objectContaining({ status: 'qa' }) }),
+      }),
+      expect.any(Object),
     );
   });
 
   it('GIVEN_feature_blocked_with_force_and_merge_gate_mode_WHEN_execute_called_THEN_patches_status_to_ready_to_merge', async () => {
     const callMock = vi.fn().mockImplementation(async (toolName: string) => {
       if (toolName === TOOLS.FEATURE_STATE_GET) {
-        return { ok: true, data: { front_matter: { version: 4, status: 'blocked', evidence: { last_gate_mode: 'merge' } } } };
+        return {
+          ok: true,
+          data: {
+            front_matter: { version: 4, status: 'blocked', evidence: { last_gate_mode: 'merge' } },
+          },
+        };
       }
       if (toolName === TOOLS.GATES_RUN) {
         return { ok: true, data: { overall: 'pass' } };
@@ -387,13 +434,21 @@ describe('RetryCommandHandler branch coverage', () => {
       return { ok: true, data: {} };
     });
     const handler = new RetryCommandHandler({ call: callMock } as never, 'run:test');
-    const result = await handler.execute({ command: 'retry', feature_id: 'feature_m', force: true }) as Record<string, unknown>;
+    const result = (await handler.execute({
+      command: 'retry',
+      feature_id: 'feature_m',
+      force: true,
+    })) as Record<string, unknown>;
     const data = result.data as Record<string, unknown>;
     expect(data.retry_mode).toBe('merge');
     expect(callMock).toHaveBeenCalledWith(
       TOOLS.FEATURE_STATE_PATCH,
-      expect.objectContaining({ patch: expect.objectContaining({ front_matter: expect.objectContaining({ status: 'ready_to_merge' }) }) }),
-      expect.any(Object)
+      expect.objectContaining({
+        patch: expect.objectContaining({
+          front_matter: expect.objectContaining({ status: 'ready_to_merge' }),
+        }),
+      }),
+      expect.any(Object),
     );
   });
 });
@@ -440,12 +495,10 @@ describe('HelpCommandHandler', () => {
 
 describe('StatusCommandHandler feature with no timestamp', () => {
   it('GIVEN_feature_with_no_timestamp_fields_WHEN_summary_THEN_activity_is_unknown', async () => {
-    const features = [
-      { feature_id: 'feat_no_ts', status: 'planning' }
-    ];
+    const features = [{ feature_id: 'feat_no_ts', status: 'planning' }];
     const toolClient = { call: vi.fn(async () => ({ ok: true, data: { features } })) };
     const handler = new StatusCommandHandler(toolClient as never, 'run:test');
-    const result = await handler.execute({ summary: true }) as any;
+    const result = (await handler.execute({ summary: true })) as any;
     expect(result.ok).toBe(true);
     const found = result.data.summary.find((f: any) => f.feature_id === 'feat_no_ts');
     expect(found?.activity).toBe('unknown');
@@ -462,13 +515,13 @@ describe('StatusCommandHandler explicit activity_state branches', () => {
             { feature_id: 'feat_idle', status: 'building', activity_state: 'idle' },
             { feature_id: 'feat_waiting', status: 'building', activity_state: 'waiting_input' },
             { feature_id: 'feat_blocked', status: 'blocked', activity_state: 'blocked' },
-            { feature_id: 'feat_exited', status: 'failed', activity_state: 'exited' }
-          ]
-        }
-      }))
+            { feature_id: 'feat_exited', status: 'failed', activity_state: 'exited' },
+          ],
+        },
+      })),
     };
     const handler = new StatusCommandHandler(toolClient as never, 'run:test');
-    const result = await handler.execute({ summary: true }) as any;
+    const result = (await handler.execute({ summary: true })) as any;
     expect(result.ok).toBe(true);
     const idle = result.data.summary.find((f: any) => f.feature_id === 'feat_idle');
     expect(idle?.activity).toBe('idle');
@@ -493,15 +546,15 @@ describe('StatusCommandHandler explicit activity_state branches', () => {
                 merge_ready: true,
                 pending_review_threads: 0,
                 has_conflicts: false,
-                merge_score: 1
-              }
-            }
-          ]
-        }
-      }))
+                merge_score: 1,
+              },
+            },
+          ],
+        },
+      })),
     };
     const handler = new StatusCommandHandler(toolClient as never, 'run:test');
-    const result = await handler.execute({}) as any;
+    const result = (await handler.execute({})) as any;
     expect(result.ok).toBe(true);
     expect(result.data.features[0].pr_info.number).toBe(42);
   });