agentic-orchestrator 0.1.28 → 0.2.0

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

@@ -1,3 +1,5 @@
+import fs from 'node:fs/promises';
+import os from 'node:os';
 import path from 'node:path';
 import { beforeEach, describe, expect, it, vi } from 'vitest';
 import { ERROR_CODES } from '../src/core/error-codes.js';
@@ -60,6 +62,18 @@ describe('cli helper modules', () => {
       command: 'run',
       file_input: '.aop/features/feature_x/spec.md',
     });
+    expect(parser.parse(['--fi', '.aop/features/feature_y/spec.md'])).toMatchObject({
+      command: 'run',
+      file_input: '.aop/features/feature_y/spec.md',
+    });
+    expect(parser.parse(['--fl', 'spec-files'])).toMatchObject({
+      command: 'run',
+      folder_input: 'spec-files',
+    });
+    expect(parser.parse(['add', '--resume', 'feature_stale'])).toMatchObject({
+      command: 'add',
+      resume_feature_id: 'feature_stale',
+    });
 
     const parsed = parser.parse([
       'run',
@@ -177,6 +191,36 @@ describe('cli helper modules', () => {
       }),
     );
   });
+
+  it('GIVEN_merge_command_flags_WHEN_parsing_THEN_captures_strategy_commit_message_and_approval_token', () => {
+    const parser = new CliArgumentParser();
+
+    const full = parser.parse([
+      'merge',
+      '--feature-id',
+      'feature_x',
+      '--strategy',
+      'squash',
+      '--commit-message',
+      'Custom merge message',
+      '--approval-token',
+      'approve_abc123',
+    ]);
+    expect(full).toMatchObject({
+      command: 'merge',
+      feature_id: 'feature_x',
+      merge_strategy: 'squash',
+      commit_message: 'Custom merge message',
+      approval_token: 'approve_abc123',
+    });
+
+    // defaults: no --strategy / --commit-message / --approval-token
+    const minimal = parser.parse(['merge', '--feature-id', 'feature_y']);
+    expect(minimal).toMatchObject({ command: 'merge', feature_id: 'feature_y' });
+    expect(minimal.merge_strategy).toBeUndefined();
+    expect(minimal.commit_message).toBeUndefined();
+    expect(minimal.approval_token).toBeUndefined();
+  });
 });
 
 describe('RetryCommandHandler', () => {
@@ -200,14 +244,11 @@ describe('RetryCommandHandler', () => {
     ).rejects.toMatchObject({ code: ERROR_CODES.INVALID_CLI_ARGS });
   });
 
-  it('GIVEN_valid_feature_id_no_force_WHEN_execute_called_THEN_runs_retry_gate_without_reset', async () => {
+  it('GIVEN_valid_feature_id_no_force_WHEN_execute_called_THEN_reroutes_at_same_phase_without_running_gate', async () => {
     const callMock = vi.fn().mockImplementation(async (toolName: string) => {
       if (toolName === TOOLS.FEATURE_STATE_GET) {
         return { ok: true, data: { front_matter: { version: 5, status: 'qa' } } };
       }
-      if (toolName === TOOLS.GATES_RUN) {
-        return { ok: true, data: { overall: 'pass' } };
-      }
       return { ok: true, data: {} };
     });
     const handler = new RetryCommandHandler({ call: callMock } as never, 'run:test');
@@ -216,19 +257,18 @@ describe('RetryCommandHandler', () => {
       ok: true,
       data: {
         feature_id: 'feature_abc',
-        retry_count_reset: false,
-        retry_executed: true,
+        retry_count_reset: true,
+        retry_executed: false,
         retry_mode: 'full',
-        retry_outcome: 'pass',
+        retry_outcome: null,
+        reroute_status: 'qa',
       },
     });
-    expect(callMock).toHaveBeenCalledWith(
+    expect(callMock).not.toHaveBeenCalledWith(
       TOOLS.GATES_RUN,
-      expect.objectContaining({ feature_id: 'feature_abc', mode: 'full' }),
-      expect.any(Object),
+      expect.anything(),
+      expect.anything(),
     );
-    const gatesRunCall = callMock.mock.calls.find((call) => call[0] === TOOLS.GATES_RUN);
-    expect(gatesRunCall?.[1]).not.toHaveProperty('profile');
   });
 
   it('GIVEN_valid_feature_id_with_force_WHEN_execute_called_THEN_gets_current_state_and_patches_retry_count', async () => {
@@ -270,6 +310,92 @@ describe('RetryCommandHandler', () => {
     const gatesRunCall = callMock.mock.calls.find((call) => call[0] === TOOLS.GATES_RUN);
     expect(gatesRunCall?.[1]).not.toHaveProperty('profile');
   });
+
+  it('GIVEN_awaiting_input_feature_WHEN_execute_called_THEN_returns_waiting_result_without_running_gates', async () => {
+    const callMock = vi.fn().mockImplementation(async (toolName: string) => {
+      if (toolName === TOOLS.FEATURE_STATE_GET) {
+        return {
+          ok: true,
+          data: {
+            front_matter: {
+              version: 5,
+              status: 'awaiting_input',
+              human_input: { open_question_count: 1 },
+            },
+          },
+        };
+      }
+      return { ok: true, data: {} };
+    });
+    const handler = new RetryCommandHandler({ call: callMock } as never, 'run:test');
+
+    const result = (await handler.execute({
+      command: 'retry',
+      feature_id: 'feature_waiting',
+    })) as Record<string, unknown>;
+
+    expect(result).toMatchObject({
+      ok: true,
+      data: {
+        feature_id: 'feature_waiting',
+        retry_executed: false,
+        reroute_status: 'awaiting_input',
+        waiting_for_input: true,
+        open_question_count: 1,
+      },
+    });
+    expect(callMock).toHaveBeenCalledTimes(1);
+    expect(callMock).toHaveBeenCalledWith(
+      TOOLS.FEATURE_STATE_GET,
+      expect.objectContaining({ feature_id: 'feature_waiting' }),
+      expect.any(Object),
+    );
+  });
+
+  it('GIVEN_blocked_feature_with_open_question_WHEN_execute_called_THEN_returns_waiting_result_without_running_gates', async () => {
+    const callMock = vi.fn().mockImplementation(async (toolName: string) => {
+      if (toolName === TOOLS.FEATURE_STATE_GET) {
+        return {
+          ok: true,
+          data: {
+            front_matter: {
+              version: 12,
+              status: 'blocked',
+              human_input: {
+                open_question_id: 'q_open',
+                open_question_count: 1,
+                resume_status: 'intake',
+              },
+            },
+          },
+        };
+      }
+      return { ok: true, data: {} };
+    });
+    const handler = new RetryCommandHandler({ call: callMock } as never, 'run:test');
+
+    const result = (await handler.execute({
+      command: 'retry',
+      feature_id: 'feature_waiting',
+    })) as Record<string, unknown>;
+
+    expect(result).toMatchObject({
+      ok: true,
+      data: {
+        feature_id: 'feature_waiting',
+        retry_executed: false,
+        reroute_status: 'awaiting_input',
+        waiting_for_input: true,
+        open_question_count: 1,
+      },
+    });
+    expect(callMock).toHaveBeenCalledTimes(1);
+    expect(callMock).toHaveBeenCalledWith(
+      TOOLS.FEATURE_STATE_GET,
+      expect.objectContaining({ feature_id: 'feature_waiting' }),
+      expect.any(Object),
+    );
+  });
 });
 
 describe('StatusCommandHandler', () => {
@@ -343,6 +469,133 @@ describe('StatusCommandHandler', () => {
     const data = (result as { ok: boolean; data: { features: Record<string, unknown>[] } }).data;
     expect(data.features[0]).not.toHaveProperty('pr_info');
   });
+
+  it('GIVEN_dashboard_execution_requests_WHEN_execute_THEN_preserves_request_visibility', async () => {
+    const toolClient = {
+      call: vi.fn(async () => ({
+        ok: true,
+        data: {
+          features: [],
+          execution_requests: {
+            version: 1,
+            run_id: 'run:active',
+            owner_instance_id: 'owner:active',
+            updated_at: new Date(0).toISOString(),
+            items: [
+              {
+                request_id: 'exec_req_001',
+                status: 'pending',
+                progress: {
+                  detected_at: new Date(0).toISOString(),
+                  last_evaluated_at: new Date(0).toISOString(),
+                  queued: [],
+                  skipped: [],
+                  deferred: [{ feature_id: 'feature_a', reason: 'capacity_full' }],
+                },
+              },
+            ],
+          },
+        },
+      })),
+    };
+    const handler = new StatusCommandHandler(toolClient as never, 'run:test');
+    const result = await handler.execute();
+
+    expect(result).toMatchObject({
+      ok: true,
+      data: {
+        execution_requests: {
+          run_id: 'run:active',
+          items: [
+            {
+              request_id: 'exec_req_001',
+              status: 'pending',
+              pending_state: 'pending_deferred',
+            },
+          ],
+        },
+      },
+    });
+  });
+
+  it('GIVEN_execution_requests_with_detected_unseen_and_non_pending_states_WHEN_execute_THEN_projects_each_request_state_correctly', async () => {
+    const toolClient = {
+      call: vi.fn(async () => ({
+        ok: true,
+        data: {
+          features: [],
+          execution_requests: {
+            version: 1,
+            run_id: 'run:active',
+            owner_instance_id: 'owner:active',
+            updated_at: new Date(0).toISOString(),
+            items: [
+              {
+                request_id: 'exec_req_detected',
+                status: 'pending',
+                progress: {
+                  detected_at: new Date(0).toISOString(),
+                  deferred: [],
+                },
+              },
+              {
+                request_id: 'exec_req_unseen',
+                status: 'pending',
+                progress: {
+                  deferred: [],
+                },
+              },
+              {
+                request_id: 'exec_req_running',
+                status: 'running',
+                progress: {
+                  detected_at: new Date(0).toISOString(),
+                  deferred: [{ feature_id: 'feature_a', reason: 'capacity_full' }],
+                },
+              },
+            ],
+          },
+        },
+      })),
+    };
+    const handler = new StatusCommandHandler(toolClient as never, 'run:test');
+    const result = (await handler.execute()) as {
+      ok: boolean;
+      data: {
+        execution_requests: {
+          items: Array<Record<string, unknown>>;
+        };
+      };
+    };
+
+    expect(result.ok).toBe(true);
+    expect(result.data.execution_requests.items).toEqual([
+      expect.objectContaining({
+        request_id: 'exec_req_detected',
+        status: 'pending',
+        pending_state: 'pending_detected',
+        detected: true,
+        defer_reasons: [],
+      }),
+      expect.objectContaining({
+        request_id: 'exec_req_unseen',
+        status: 'pending',
+        pending_state: 'pending_unseen',
+        detected: false,
+        defer_reasons: [],
+      }),
+      expect.objectContaining({
+        request_id: 'exec_req_running',
+        status: 'running',
+        progress: expect.objectContaining({
+          detected_at: expect.any(String),
+        }),
+      }),
+    ]);
+    expect(result.data.execution_requests.items[2]).not.toHaveProperty('pending_state');
+    expect(result.data.execution_requests.items[2]).not.toHaveProperty('detected');
+    expect(result.data.execution_requests.items[2]).not.toHaveProperty('defer_reasons');
+  });
 });
 
 describe('SendCommandHandler', () => {
@@ -369,6 +622,46 @@ describe('RetryCommandHandler branch coverage', () => {
     ).rejects.toMatchObject({ code: ERROR_CODES.INVALID_CLI_ARGS });
   });
 
+  it('GIVEN_feature_in_failed_status_without_force_WHEN_execute_called_THEN_throws_invalid_cli_args', async () => {
+    const callMock = vi.fn().mockImplementation(async (toolName: string) => {
+      if (toolName === TOOLS.FEATURE_STATE_GET) {
+        return { ok: true, data: { front_matter: { version: 1, status: 'failed' } } };
+      }
+      return { ok: true, data: {} };
+    });
+    const handler = new RetryCommandHandler({ call: callMock } as never, 'run:test');
+    await expect(
+      handler.execute({ command: 'retry', feature_id: 'feature_failed' }),
+    ).rejects.toMatchObject({ code: ERROR_CODES.INVALID_CLI_ARGS });
+  });
+
+  it('GIVEN_feature_in_building_status_WHEN_execute_called_THEN_reroutes_at_same_phase_with_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: 'building' } } };
+      }
+      return { ok: true, data: {} };
+    });
+    const handler = new RetryCommandHandler({ call: callMock } as never, 'run:test');
+    const result = (await handler.execute({
+      command: 'retry',
+      feature_id: 'feature_building',
+    })) as Record<string, unknown>;
+
+    expect(result.data).toMatchObject({
+      retry_mode: 'fast',
+      retry_outcome: null,
+      reroute_status: 'building',
+      retry_executed: false,
+      retry_count_reset: true,
+    });
+    expect(callMock).not.toHaveBeenCalledWith(
+      TOOLS.GATES_RUN,
+      expect.anything(),
+      expect.anything(),
+    );
+  });
+
   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) {
@@ -461,6 +754,340 @@ describe('RetryCommandHandler branch coverage', () => {
       expect.any(Object),
     );
   });
+
+  it('GIVEN_blocked_merge_gate_failure_WHEN_retry_executed_THEN_reroutes_to_qa_and_increments_merge_repair_attempt', async () => {
+    const callMock = vi.fn().mockImplementation(async (toolName: string) => {
+      if (toolName === TOOLS.FEATURE_STATE_GET) {
+        return {
+          ok: true,
+          data: {
+            front_matter: {
+              version: 12,
+              status: 'blocked',
+              gates: { merge: 'fail' },
+              evidence: { last_gate_mode: 'merge' },
+              merge_repair: { attempts: 2, max_attempts: 5, active: true },
+            },
+          },
+        };
+      }
+      return { ok: true, data: {} };
+    });
+    const handler = new RetryCommandHandler({ call: callMock } as never, 'run:test');
+
+    const result = (await handler.execute({
+      command: 'retry',
+      feature_id: 'feature_merge_repair',
+    })) as Record<string, unknown>;
+
+    expect(result.data).toMatchObject({
+      retry_executed: false,
+      retry_mode: 'merge',
+      reroute_status: 'qa',
+      merge_repair_attempt: 3,
+      merge_repair_max_attempts: 5,
+    });
+    expect(callMock).toHaveBeenCalledWith(
+      TOOLS.FEATURE_STATE_PATCH,
+      expect.objectContaining({
+        patch: expect.objectContaining({
+          front_matter: expect.objectContaining({
+            status: 'qa',
+            status_reason: 'merge_gate_repair:3',
+            merge_repair: expect.objectContaining({ attempts: 3, max_attempts: 5 }),
+          }),
+        }),
+      }),
+      expect.any(Object),
+    );
+    expect(callMock).not.toHaveBeenCalledWith(
+      TOOLS.GATES_RUN,
+      expect.anything(),
+      expect.anything(),
+    );
+  });
+
+  it('GIVEN_blocked_merge_gate_failure_with_exhausted_budget_WHEN_retry_executed_THEN_does_not_reroute', async () => {
+    const callMock = vi.fn().mockImplementation(async (toolName: string) => {
+      if (toolName === TOOLS.FEATURE_STATE_GET) {
+        return {
+          ok: true,
+          data: {
+            front_matter: {
+              version: 14,
+              status: 'blocked',
+              gates: { merge: 'fail' },
+              evidence: { last_gate_mode: 'merge' },
+              merge_repair: { attempts: 5, max_attempts: 5, active: true },
+            },
+          },
+        };
+      }
+      return { ok: true, data: {} };
+    });
+    const handler = new RetryCommandHandler({ call: callMock } as never, 'run:test');
+
+    const result = (await handler.execute({
+      command: 'retry',
+      feature_id: 'feature_merge_exhausted',
+    })) as Record<string, unknown>;
+
+    expect(result.data).toMatchObject({
+      retry_executed: false,
+      retry_mode: 'merge',
+      retry_outcome: 'fail',
+      merge_repair_exhausted: true,
+      reroute_status: null,
+    });
+    expect(callMock).not.toHaveBeenCalledWith(
+      TOOLS.FEATURE_STATE_PATCH,
+      expect.anything(),
+      expect.anything(),
+    );
+  });
+
+  it('GIVEN_force_retry_on_non_blocked_feature_WHEN_execute_called_THEN_resets_retry_budget_without_status_reroute', async () => {
+    const callMock = vi.fn().mockImplementation(async (toolName: string) => {
+      if (toolName === TOOLS.FEATURE_STATE_GET) {
+        return { ok: true, data: { front_matter: { version: 7, status: 'qa' } } };
+      }
+      if (toolName === TOOLS.GATES_RUN) {
+        return { ok: true, data: { overall: 'pass' } };
+      }
+      return { ok: true, data: {} };
+    });
+    const handler = new RetryCommandHandler({ call: callMock } as never, 'run:test');
+
+    await handler.execute({
+      command: 'retry',
+      feature_id: 'feature_force',
+      force: true,
+    });
+
+    expect(callMock).toHaveBeenCalledWith(
+      TOOLS.FEATURE_STATE_PATCH,
+      expect.objectContaining({
+        patch: {
+          front_matter: {
+            gate_retry_count: 0,
+            last_retry_at: null,
+          },
+        },
+      }),
+      expect.any(Object),
+    );
+  });
+
+  it('GIVEN_gate_result_without_overall_WHEN_execute_called_THEN_returns_null_retry_outcome', async () => {
+    const callMock = vi.fn().mockImplementation(async (toolName: string) => {
+      if (toolName === TOOLS.FEATURE_STATE_GET) {
+        return { ok: true, data: { front_matter: { version: 4, status: 'qa' } } };
+      }
+      if (toolName === TOOLS.GATES_RUN) {
+        return { ok: true, data: {} };
+      }
+      return { ok: true, data: {} };
+    });
+    const handler = new RetryCommandHandler({ call: callMock } as never, 'run:test');
+    const result = (await handler.execute({
+      command: 'retry',
+      feature_id: 'feature_null_outcome',
+    })) as Record<string, unknown>;
+
+    expect(result.data).toMatchObject({ retry_mode: 'full', retry_outcome: null });
+  });
+
+  it('GIVEN_blocked_fast_gate_retry_WHEN_execute_called_THEN_reroutes_to_building_without_running_gates', async () => {
+    const callMock = vi.fn(async (toolName: string) => {
+      if (toolName === TOOLS.FEATURE_STATE_GET) {
+        return {
+          ok: true,
+          data: {
+            front_matter: {
+              version: 1,
+              status: 'blocked',
+              gates: { fast: 'fail' },
+            },
+          },
+        };
+      }
+      return { ok: true, data: {} };
+    });
+
+    const handler = new RetryCommandHandler({ call: callMock } as never, 'run:test');
+    const result = (await handler.execute({
+      command: 'retry',
+      feature_id: 'feature_fast',
+    })) as Record<string, unknown>;
+
+    expect(callMock).toHaveBeenCalledWith(
+      TOOLS.FEATURE_STATE_PATCH,
+      expect.objectContaining({
+        patch: expect.objectContaining({
+          front_matter: expect.objectContaining({
+            status: 'building',
+            status_reason: 'retry_resume:fast',
+            gate_retry_count: 0,
+          }),
+        }),
+      }),
+      expect.anything(),
+    );
+    expect(result.data).toMatchObject({
+      retry_executed: false,
+      retry_mode: 'fast',
+      reroute_status: 'building',
+    });
+    expect(callMock).not.toHaveBeenCalledWith(
+      TOOLS.GATES_RUN,
+      expect.anything(),
+      expect.anything(),
+    );
+  });
+
+  it('GIVEN_blocked_full_gate_retry_WHEN_execute_called_THEN_reroutes_to_qa_without_running_gates', async () => {
+    const callMock = vi.fn(async (toolName: string) => {
+      if (toolName === TOOLS.FEATURE_STATE_GET) {
+        return {
+          ok: true,
+          data: {
+            front_matter: {
+              version: 1,
+              status: 'blocked',
+              gates: { full: 'fail' },
+            },
+          },
+        };
+      }
+      return { ok: true, data: {} };
+    });
+
+    const handler = new RetryCommandHandler({ call: callMock } as never, 'run:test');
+    const result = (await handler.execute({
+      command: 'retry',
+      feature_id: 'feature_full',
+    })) as Record<string, unknown>;
+
+    expect(callMock).toHaveBeenCalledWith(
+      TOOLS.FEATURE_STATE_PATCH,
+      expect.objectContaining({
+        patch: expect.objectContaining({
+          front_matter: expect.objectContaining({
+            status: 'qa',
+            status_reason: 'retry_resume:full',
+            gate_retry_count: 0,
+          }),
+        }),
+      }),
+      expect.any(Object),
+    );
+    expect(result.data).toMatchObject({
+      retry_executed: false,
+      retry_mode: 'full',
+      reroute_status: 'qa',
+    });
+    expect(callMock).not.toHaveBeenCalledWith(
+      TOOLS.GATES_RUN,
+      expect.anything(),
+      expect.anything(),
+    );
+  });
+
+  it('GIVEN_checkpoint_invalid_WHEN_execute_called_THEN_treats_it_as_warning_and_runs_retry', async () => {
+    const callMock = vi.fn(async (toolName: string) => {
+      if (toolName === TOOLS.FEATURE_STATE_GET) {
+        return {
+          ok: true,
+          data: {
+            front_matter: {
+              version: 1,
+              status: 'building',
+              checkpoints: [
+                {
+                  checkpoint_id: 'checkpoint-1',
+                  timestamp: '2026-03-12T15:00:00.000Z',
+                  files_changed: ['apps/control-plane/src/supervisor/run-coordinator.ts'],
+                  validation_status: 'invalid',
+                  diff_snapshot: '.aop/features/feature_fast/checkpoints/checkpoint-1.diff',
+                  violations: ['outside_allowed_areas'],
+                },
+              ],
+            },
+          },
+        };
+      }
+      if (toolName === TOOLS.GATES_RUN) {
+        return { ok: true, data: { overall: 'pass' } };
+      }
+      return { ok: true, data: {} };
+    });
+
+    const handler = new RetryCommandHandler({ call: callMock } as never, 'run:test');
+    const result = (await handler.execute({
+      command: 'retry',
+      feature_id: 'feature_fast',
+    })) as Record<string, unknown>;
+
+    expect(callMock).not.toHaveBeenCalledWith(
+      TOOLS.GATES_RUN,
+      expect.anything(),
+      expect.anything(),
+    );
+    expect(result.data).toMatchObject({
+      retry_executed: false,
+      reroute_status: 'building',
+      retry_count_reset: true,
+    });
+  });
+
+  it('GIVEN_warning_only_invalid_checkpoint_WHEN_execute_called_THEN_allows_retry_to_run', async () => {
+    const callMock = vi.fn(async (toolName: string) => {
+      if (toolName === TOOLS.FEATURE_STATE_GET) {
+        return {
+          ok: true,
+          data: {
+            front_matter: {
+              version: 1,
+              status: 'qa',
+              checkpoints: [
+                {
+                  checkpoint_id: 'checkpoint-warning',
+                  timestamp: '2026-03-12T15:00:00.000Z',
+                  files_changed: ['apps/control-plane/src/supervisor/run-coordinator.ts'],
+                  validation_status: 'invalid',
+                  severity: 'warning',
+                  diff_snapshot:
+                    '.aop/features/feature_warning/checkpoints/checkpoint-warning.diff',
+                  violations: ['outside_allowed_areas'],
+                },
+              ],
+            },
+          },
+        };
+      }
+      if (toolName === TOOLS.GATES_RUN) {
+        return { ok: true, data: { overall: 'pass' } };
+      }
+      return { ok: true, data: {} };
+    });
+
+    const handler = new RetryCommandHandler({ call: callMock } as never, 'run:test');
+    const result = (await handler.execute({
+      command: 'retry',
+      feature_id: 'feature_warning',
+    })) as Record<string, unknown>;
+
+    expect(callMock).not.toHaveBeenCalledWith(
+      TOOLS.GATES_RUN,
+      expect.anything(),
+      expect.anything(),
+    );
+    expect(result.data).toMatchObject({
+      retry_executed: false,
+      reroute_status: 'qa',
+      retry_count_reset: true,
+    });
+  });
 });
 
 describe('HelpCommandHandler', () => {
@@ -601,4 +1228,567 @@ describe('StatusCommandHandler explicit activity_state branches', () => {
     expect(result.ok).toBe(true);
     expect(result.data.features[0].pr_info.number).toBe(42);
   });
+
+  it('GIVEN_feature_with_human_input_summary_WHEN_execute_THEN_flattens_question_fields_for_cli_output', async () => {
+    const toolClient = {
+      call: vi.fn(async () => ({
+        ok: true,
+        data: {
+          features: [
+            {
+              feature_id: 'feat_question',
+              status: 'awaiting_input',
+              activity_state: 'waiting_input',
+              human_input: {
+                open_question_id: 'q_cli',
+                open_question_count: 1,
+                awaiting_since: '2026-03-17T12:00:00.000Z',
+                requested_by_role: 'builder',
+                resume_status: 'building',
+              },
+            },
+          ],
+        },
+      })),
+    };
+    const handler = new StatusCommandHandler(toolClient as never, 'run:test');
+
+    const summary = (await handler.execute({ summary: true })) as any;
+    const full = (await handler.execute({})) as any;
+
+    expect(summary.data.summary[0]).toMatchObject({
+      feature_id: 'feat_question',
+      activity: 'waiting_input',
+      open_question_id: 'q_cli',
+      open_question_count: 1,
+      requested_by_role: 'builder',
+      resume_status: 'building',
+    });
+    expect(full.data.features[0]).toMatchObject({
+      open_question_id: 'q_cli',
+      open_question_count: 1,
+      awaiting_since: '2026-03-17T12:00:00.000Z',
+      requested_by_role: 'builder',
+      resume_status: 'building',
+    });
+  });
+});
+
+describe('HelpCommandHandler completion visibility', () => {
+  it('GIVEN_no_subcommand_WHEN_execute_called_THEN_lists_completion_but_not_internal_complete', async () => {
+    const { HelpCommandHandler } = await import('../src/cli/help-command-handler.js');
+    const handler = new HelpCommandHandler();
+    const result = handler.execute();
+    expect(result.ok).toBe(true);
+    expect(result.data.help).toContain('completion');
+    expect(result.data.help).not.toContain('__complete');
+  });
+
+  it('GIVEN_completion_subcommand_WHEN_execute_called_THEN_returns_detailed_help', async () => {
+    const { HelpCommandHandler } = await import('../src/cli/help-command-handler.js');
+    const handler = new HelpCommandHandler();
+    const result = handler.execute('completion');
+    expect(result.ok).toBe(true);
+    expect(result.data.help).toContain('Usage: aop completion');
+  });
+
+  it('GIVEN_internal_complete_subcommand_WHEN_execute_called_THEN_falls_back_to_full_help', async () => {
+    const { HelpCommandHandler } = await import('../src/cli/help-command-handler.js');
+    const handler = new HelpCommandHandler();
+    const result = handler.execute('__complete');
+    expect(result.ok).toBe(true);
+    // Hidden command should not get detail view — falls back to full help
+    expect(result.data.help).toContain('Commands:');
+    expect(result.data.help).not.toContain('Internal tab-completion');
+  });
+});
+
+describe('command catalog completion metadata', () => {
+  it('GIVEN_public_and_hidden_commands_WHEN_querying_catalog_THEN_returns_expected_visibility_and_flags', async () => {
+    const { formatFlagUsage, getCommandFlags, getPublicCommands, isPublicCommand } =
+      await import('../src/cli/command-catalog.js');
+
+    expect(getPublicCommands()).toContain('completion');
+    expect(getPublicCommands()).not.toContain('__complete');
+    expect(getCommandFlags('bogus')).toEqual([]);
+    expect(isPublicCommand('completion')).toBe(true);
+    expect(isPublicCommand('__complete')).toBe(false);
+    expect(isPublicCommand('bogus')).toBe(false);
+    expect(
+      formatFlagUsage({
+        aliases: ['--project'],
+        description: 'Project name',
+        takesValue: true,
+        valueHint: 'name',
+      }),
+    ).toBe('--project <name>');
+    expect(
+      formatFlagUsage({
+        aliases: ['--summary'],
+        description: 'Summary mode',
+        takesValue: false,
+      }),
+    ).toBe('--summary');
+  });
+});
+
+describe('CliArgumentParser completion command', () => {
+  it('GIVEN_completion_bash_WHEN_parsing_THEN_captures_shell', () => {
+    const parser = new CliArgumentParser();
+    const result = parser.parse(['completion', 'bash']);
+    expect(result).toMatchObject({ command: 'completion', shell: 'bash' });
+  });
+
+  it('GIVEN_completion_zsh_WHEN_parsing_THEN_captures_shell', () => {
+    const parser = new CliArgumentParser();
+    const result = parser.parse(['completion', 'zsh']);
+    expect(result).toMatchObject({ command: 'completion', shell: 'zsh' });
+  });
+
+  it('GIVEN_completion_fish_WHEN_parsing_THEN_captures_shell', () => {
+    const parser = new CliArgumentParser();
+    const result = parser.parse(['completion', 'fish']);
+    expect(result).toMatchObject({ command: 'completion', shell: 'fish' });
+  });
+
+  it('GIVEN_completion_no_shell_WHEN_parsing_THEN_shell_is_undefined', () => {
+    const parser = new CliArgumentParser();
+    const result = parser.parse(['completion']);
+    expect(result.command).toBe('completion');
+    expect(result.shell).toBeUndefined();
+  });
+
+  it('GIVEN_internal_complete_WHEN_parsing_THEN_command_is_internal_complete', () => {
+    const parser = new CliArgumentParser();
+    const result = parser.parse(['__complete', '--', 'aop', 'sta']);
+    expect(result.command).toBe('__complete');
+  });
+
+  it('GIVEN_invalid_optional_values_WHEN_parsing_THEN_invalid_tokens_do_not_consume_following_flags', () => {
+    const parser = new CliArgumentParser();
+    const result = parser.parse([
+      'run',
+      '--execution-mode',
+      'bogus',
+      '--worker-provider-mode',
+      'nope',
+      '--from-sequence',
+      'NaN',
+      '--limit',
+      'also-bad',
+      '--help',
+    ]);
+
+    expect(result.command).toBe('help');
+    expect(result.execution_mode).toBeUndefined();
+    expect(result.worker_provider_mode).toBeUndefined();
+    expect(result.from_sequence).toBeUndefined();
+    expect(result.limit).toBeUndefined();
+  });
+});
+
+describe('CompletionCommandHandler', () => {
+  it('GIVEN_bash_shell_WHEN_execute_called_THEN_returns_bash_script', async () => {
+    const { CompletionCommandHandler } = await import('../src/cli/completion-command-handler.js');
+    const handler = new CompletionCommandHandler();
+    const result = handler.execute('bash');
+    expect(result.ok).toBe(true);
+    expect(result.data.script).toContain('_aop_completion');
+    expect(result.data.script).toContain('aop __complete bash "$COMP_CWORD" "${COMP_WORDS[@]:1}"');
+    expect(result.data.script).toContain('complete -F _aop_completion aop');
+  });
+
+  it('GIVEN_zsh_shell_WHEN_execute_called_THEN_returns_zsh_script', async () => {
+    const { CompletionCommandHandler } = await import('../src/cli/completion-command-handler.js');
+    const handler = new CompletionCommandHandler();
+    const result = handler.execute('zsh');
+    expect(result.ok).toBe(true);
+    expect(result.data.script).toContain('aop __complete zsh "$CURRENT" "${words[@]:2}"');
+    expect(result.data.script).toContain('compdef _aop_completion aop');
+  });
+
+  it('GIVEN_fish_shell_WHEN_execute_called_THEN_returns_fish_script', async () => {
+    const { CompletionCommandHandler } = await import('../src/cli/completion-command-handler.js');
+    const handler = new CompletionCommandHandler();
+    const result = handler.execute('fish');
+    expect(result.ok).toBe(true);
+    expect(result.data.script).toContain('complete -c aop');
+  });
+
+  it('GIVEN_unsupported_shell_WHEN_execute_called_THEN_throws_error_with_invalid_cli_args_code', async () => {
+    const { CompletionCommandHandler } = await import('../src/cli/completion-command-handler.js');
+    const handler = new CompletionCommandHandler();
+    let caught: unknown;
+    try {
+      handler.execute('powershell');
+    } catch (e) {
+      caught = e;
+    }
+    expect((caught as Record<string, unknown>).code).toBe(ERROR_CODES.INVALID_CLI_ARGS);
+  });
+
+  it('GIVEN_undefined_shell_WHEN_execute_called_THEN_throws_error_with_invalid_cli_args_code', async () => {
+    const { CompletionCommandHandler } = await import('../src/cli/completion-command-handler.js');
+    const handler = new CompletionCommandHandler();
+    let caught: unknown;
+    try {
+      handler.execute(undefined);
+    } catch (e) {
+      caught = e;
+    }
+    expect((caught as Record<string, unknown>).code).toBe(ERROR_CODES.INVALID_CLI_ARGS);
+  });
+});
+
+describe('CompleteCommandHandler', () => {
+  it('GIVEN_empty_args_WHEN_resolve_called_THEN_returns_empty_array', async () => {
+    const { CompleteCommandHandler } = await import('../src/cli/complete-command-handler.js');
+    const handler = new CompleteCommandHandler();
+    const candidates = handler.resolve([]);
+    expect(candidates).toEqual([]);
+  });
+
+  it('GIVEN_aop_prefix_only_WHEN_resolve_called_THEN_returns_public_commands', async () => {
+    const { CompleteCommandHandler } = await import('../src/cli/complete-command-handler.js');
+    const handler = new CompleteCommandHandler();
+    const candidates = handler.resolve(['bash', '0', 'aop']);
+    expect(candidates).toContain('run');
+    expect(candidates).toContain('status');
+  });
+
+  it('GIVEN_aop_with_command_typed_WHEN_resolve_called_THEN_returns_flags_for_command', async () => {
+    const { CompleteCommandHandler } = await import('../src/cli/complete-command-handler.js');
+    const handler = new CompleteCommandHandler();
+    const candidates = handler.resolve(['bash', '2', 'aop', 'status', '--']);
+    expect(candidates).toContain('--summary');
+    expect(candidates).toContain('--project');
+  });
+
+  it('GIVEN_unknown_command_WHEN_resolve_called_THEN_returns_empty_array', async () => {
+    const { CompleteCommandHandler } = await import('../src/cli/complete-command-handler.js');
+    const handler = new CompleteCommandHandler();
+    const candidates = handler.resolve(['bash', '2', 'aop', 'bogus', '--']);
+    expect(candidates).toEqual([]);
+  });
+
+  it('GIVEN_resolver_throwing_WHEN_resolve_called_THEN_returns_empty_array', async () => {
+    vi.resetModules();
+    vi.doMock('../src/cli/completion-resolver.js', () => ({
+      resolveCompletionCandidates: () => {
+        throw new Error('boom');
+      },
+    }));
+
+    const { CompleteCommandHandler } = await import('../src/cli/complete-command-handler.js');
+    const handler = new CompleteCommandHandler();
+    expect(handler.resolve(['bash', '0', 'aop'])).toEqual([]);
+
+    vi.doUnmock('../src/cli/completion-resolver.js');
+    vi.resetModules();
+  });
+});
+
+describe('CompletionResolver', () => {
+  it('GIVEN_empty_shell_words_WHEN_resolving_THEN_returns_empty', async () => {
+    const { resolveCompletionCandidates } = await import('../src/cli/completion-resolver.js');
+    const candidates = resolveCompletionCandidates([]);
+    expect(candidates).toEqual([]);
+  });
+
+  it('GIVEN_aop_only_WHEN_resolving_THEN_returns_all_public_commands', async () => {
+    const { resolveCompletionCandidates } = await import('../src/cli/completion-resolver.js');
+    const candidates = resolveCompletionCandidates(['bash', '0', 'aop']);
+    expect(candidates).toContain('run');
+    expect(candidates).toContain('merge');
+    expect(candidates).toContain('completion');
+    expect(candidates).not.toContain('__complete');
+  });
+
+  it('GIVEN_aop_status_args_WHEN_resolving_THEN_returns_status_flags', async () => {
+    const { resolveCompletionCandidates } = await import('../src/cli/completion-resolver.js');
+    const candidates = resolveCompletionCandidates(['bash', '2', 'aop', 'status', '--']);
+    expect(candidates).toContain('--summary');
+    expect(candidates).toContain('--all');
+  });
+
+  it('GIVEN_legacy_backend_args_WHEN_resolving_THEN_supports_empty_and_command_flags', async () => {
+    const { resolveCompletionCandidates } = await import('../src/cli/completion-resolver.js');
+
+    expect(resolveCompletionCandidates(['--'])).toContain('run');
+
+    const candidates = resolveCompletionCandidates(['--', 'status', '--']);
+    expect(candidates).toContain('--summary');
+    expect(candidates).toContain('--project');
+  });
+
+  it('GIVEN_legacy_backend_args_with_aop_prefix_WHEN_resolving_THEN_normalizes_prefix', async () => {
+    const { resolveCompletionCandidates } = await import('../src/cli/completion-resolver.js');
+    const candidates = resolveCompletionCandidates(['--', 'aop', 'status', '--']);
+    expect(candidates).toContain('--summary');
+    expect(candidates).toContain('--project');
+  });
+
+  it('GIVEN_aop_run_args_WHEN_resolving_THEN_returns_run_flags_including_fi', async () => {
+    const { resolveCompletionCandidates } = await import('../src/cli/completion-resolver.js');
+    const candidates = resolveCompletionCandidates(['bash', '1', 'aop', 'run']);
+    expect(candidates).toContain('-fi');
+    expect(candidates).toContain('-fl');
+    expect(candidates).toContain('--batch');
+  });
+
+  it('GIVEN_completion_command_value_position_WHEN_resolving_THEN_returns_supported_shells', async () => {
+    const { resolveCompletionCandidates } = await import('../src/cli/completion-resolver.js');
+    const candidates = resolveCompletionCandidates(['bash', '2', 'aop', 'completion', '']);
+    expect(candidates).toEqual(['bash', 'zsh', 'fish']);
+  });
+
+  it('GIVEN_zsh_and_fish_indices_WHEN_resolving_THEN_normalizes_shell_specific_cursor_positions', async () => {
+    const { resolveCompletionCandidates } = await import('../src/cli/completion-resolver.js');
+
+    expect(resolveCompletionCandidates(['zsh', '3', 'aop', 'completion', ''])).toEqual([
+      'bash',
+      'zsh',
+      'fish',
+    ]);
+
+    const fishCandidates = resolveCompletionCandidates(['fish', '1', 'status', '--']);
+    expect(fishCandidates).toContain('--summary');
+    expect(fishCandidates).toContain('--project');
+  });
+
+  it('GIVEN_non_numeric_cursor_index_WHEN_resolving_THEN_falls_back_to_command_level_flags', async () => {
+    const { resolveCompletionCandidates } = await import('../src/cli/completion-resolver.js');
+    const candidates = resolveCompletionCandidates(['bash', 'not-a-number', 'aop', 'status']);
+    expect(candidates).toContain('--summary');
+    expect(candidates).toContain('--all');
+  });
+
+  it('GIVEN_used_status_flag_WHEN_resolving_THEN_does_not_repeat_flag', async () => {
+    const { resolveCompletionCandidates } = await import('../src/cli/completion-resolver.js');
+    const candidates = resolveCompletionCandidates([
+      'bash',
+      '3',
+      'aop',
+      'status',
+      '--summary',
+      '--',
+    ]);
+    expect(candidates).not.toContain('--summary');
+    expect(candidates).toContain('--project');
+  });
+
+  it('GIVEN_multi_project_config_WHEN_resolving_project_value_THEN_returns_project_names', async () => {
+    const { resolveCompletionCandidates } = await import('../src/cli/completion-resolver.js');
+    const cwd = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-completion-projects-'));
+    try {
+      await fs.mkdir(path.join(cwd, 'config', 'agentic', 'orchestrator'), { recursive: true });
+      await fs.writeFile(
+        path.join(cwd, 'config', 'agentic', 'orchestrator', 'multi-project.yaml'),
+        [
+          'version: "1"',
+          'projects:',
+          '  - name: beta',
+          '    path: ./beta',
+          '  - name: alpha',
+          '    path: ./alpha',
+        ].join('\n'),
+        'utf8',
+      );
+
+      const candidates = resolveCompletionCandidates(
+        ['bash', '3', 'aop', 'status', '--project', ''],
+        cwd,
+      );
+      expect(candidates).toEqual(['alpha', 'beta']);
+    } finally {
+      await fs.rm(cwd, { recursive: true, force: true });
+    }
+  });
+
+  it('GIVEN_project_flag_as_current_token_WHEN_resolving_THEN_returns_project_names', async () => {
+    const { resolveCompletionCandidates } = await import('../src/cli/completion-resolver.js');
+    const cwd = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-completion-project-flag-'));
+    try {
+      await fs.mkdir(path.join(cwd, 'config', 'agentic', 'orchestrator'), { recursive: true });
+      await fs.writeFile(
+        path.join(cwd, 'config', 'agentic', 'orchestrator', 'multi-project.yaml'),
+        [
+          'version: "1"',
+          'projects:',
+          '  - name: beta',
+          '    path: ./beta',
+          '  - name: alpha',
+          '    path: ./alpha',
+        ].join('\n'),
+        'utf8',
+      );
+
+      const candidates = resolveCompletionCandidates(
+        ['bash', '2', 'aop', 'status', '--project'],
+        cwd,
+      );
+      expect(candidates).toEqual(['alpha', 'beta']);
+    } finally {
+      await fs.rm(cwd, { recursive: true, force: true });
+    }
+  });
+
+  it('GIVEN_missing_project_config_WHEN_resolving_project_value_THEN_returns_no_dynamic_candidates', async () => {
+    const { resolveCompletionCandidates } = await import('../src/cli/completion-resolver.js');
+    const cwd = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-completion-projects-missing-'));
+    try {
+      const candidates = resolveCompletionCandidates(
+        ['bash', '2', 'aop', 'status', '--project'],
+        cwd,
+      );
+      expect(candidates).toEqual([]);
+    } finally {
+      await fs.rm(cwd, { recursive: true, force: true });
+    }
+  });
+
+  it('GIVEN_worktree_gitfile_and_agentic_multi_project_config_WHEN_resolving_project_values_THEN_uses_repo_root_and_current_flag_source', async () => {
+    const { resolveCompletionCandidates } = await import('../src/cli/completion-resolver.js');
+    const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-completion-worktree-'));
+    const cwd = path.join(repoRoot, 'worktrees', 'feature-complete');
+    try {
+      await fs.mkdir(path.join(repoRoot, '.git', 'worktrees', 'feature-complete'), {
+        recursive: true,
+      });
+      await fs.mkdir(path.join(repoRoot, 'agentic', 'orchestrator'), { recursive: true });
+      await fs.mkdir(cwd, { recursive: true });
+      await fs.writeFile(
+        path.join(cwd, '.git'),
+        `gitdir: ${path.join(repoRoot, '.git', 'worktrees', 'feature-complete')}\n`,
+        'utf8',
+      );
+      await fs.writeFile(
+        path.join(repoRoot, 'agentic', 'orchestrator', 'multi-project.yaml'),
+        [
+          'version: "1"',
+          'projects:',
+          '  - name: gamma',
+          '    path: ./gamma',
+          '  - name: alpha',
+          '    path: ./alpha',
+        ].join('\n'),
+        'utf8',
+      );
+
+      const candidates = resolveCompletionCandidates(
+        ['bash', '2', 'aop', 'status', '--project'],
+        cwd,
+      );
+      expect(candidates).toEqual(['alpha', 'gamma']);
+    } finally {
+      await fs.rm(repoRoot, { recursive: true, force: true });
+    }
+  });
+
+  it('GIVEN_feature_index_WHEN_resolving_feature_id_value_THEN_returns_deduplicated_feature_ids', async () => {
+    const { resolveCompletionCandidates } = await import('../src/cli/completion-resolver.js');
+    const cwd = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-completion-features-'));
+    try {
+      await fs.mkdir(path.join(cwd, '.aop', 'features'), { recursive: true });
+      await fs.writeFile(
+        path.join(cwd, '.aop', 'features', 'index.json'),
+        JSON.stringify({
+          active: ['feature_b', 'feature_a'],
+          blocked: ['feature_a'],
+          merged: ['feature_c'],
+          blocked_queue: [{ feature_id: 'feature_d' }],
+        }),
+        'utf8',
+      );
+
+      const candidates = resolveCompletionCandidates(
+        ['bash', '3', 'aop', 'resume', '--feature-id', ''],
+        cwd,
+      );
+      expect(candidates).toEqual(['feature_a', 'feature_b', 'feature_c', 'feature_d']);
+    } finally {
+      await fs.rm(cwd, { recursive: true, force: true });
+    }
+  });
+
+  it('GIVEN_malformed_feature_index_WHEN_resolving_feature_id_value_THEN_returns_no_dynamic_candidates', async () => {
+    const { resolveCompletionCandidates } = await import('../src/cli/completion-resolver.js');
+    const cwd = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-completion-features-malformed-'));
+    try {
+      await fs.mkdir(path.join(cwd, '.aop', 'features'), { recursive: true });
+      await fs.writeFile(path.join(cwd, '.aop', 'features', 'index.json'), '{', 'utf8');
+
+      const candidates = resolveCompletionCandidates(
+        ['bash', '2', 'aop', 'resume', '--feature-id'],
+        cwd,
+      );
+      expect(candidates).toEqual([]);
+    } finally {
+      await fs.rm(cwd, { recursive: true, force: true });
+    }
+  });
+
+  it('GIVEN_sparse_feature_index_WHEN_resolving_feature_id_value_THEN_ignores_invalid_entries', async () => {
+    const { resolveCompletionCandidates } = await import('../src/cli/completion-resolver.js');
+    const cwd = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-completion-features-invalid-'));
+    try {
+      await fs.mkdir(path.join(cwd, '.aop', 'features'), { recursive: true });
+      await fs.writeFile(
+        path.join(cwd, '.aop', 'features', 'index.json'),
+        JSON.stringify({
+          active: 'feature_bad_shape',
+          blocked: ['', 'feature_b'],
+          merged: [null, 'feature_a'],
+          blocked_queue: [{ nope: true }, { feature_id: '' }, { feature_id: 'feature_c' }],
+        }),
+        'utf8',
+      );
+
+      const candidates = resolveCompletionCandidates(
+        ['bash', '2', 'aop', 'resume', '--feature-id'],
+        cwd,
+      );
+      expect(candidates).toEqual(['feature_a', 'feature_b', 'feature_c']);
+    } finally {
+      await fs.rm(cwd, { recursive: true, force: true });
+    }
+  });
+
+  it('GIVEN_repo_root_with_git_directory_WHEN_resolving_feature_id_value_THEN_uses_cwd_as_repo_root', async () => {
+    const { resolveCompletionCandidates } = await import('../src/cli/completion-resolver.js');
+    const cwd = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-completion-features-gitdir-'));
+    try {
+      await fs.mkdir(path.join(cwd, '.git'), { recursive: true });
+      await fs.mkdir(path.join(cwd, '.aop', 'features'), { recursive: true });
+      await fs.writeFile(
+        path.join(cwd, '.aop', 'features', 'index.json'),
+        JSON.stringify({
+          active: ['feature_z'],
+          blocked: [],
+          merged: ['feature_a'],
+        }),
+        'utf8',
+      );
+
+      const candidates = resolveCompletionCandidates(
+        ['bash', '2', 'aop', 'resume', '--feature-id'],
+        cwd,
+      );
+      expect(candidates).toEqual(['feature_a', 'feature_z']);
+    } finally {
+      await fs.rm(cwd, { recursive: true, force: true });
+    }
+  });
+
+  it('GIVEN_static_value_source_flag_WHEN_resolving_THEN_returns_static_candidates', async () => {
+    const { resolveCompletionCandidates } = await import('../src/cli/completion-resolver.js');
+    const candidates = resolveCompletionCandidates(['bash', '2', 'aop', 'run', '--execution-mode']);
+    expect(candidates).toEqual(['deterministic', 'interactive']);
+  });
+
+  it('GIVEN_plain_text_argument_position_WHEN_resolving_without_expected_value_THEN_returns_empty', async () => {
+    const { resolveCompletionCandidates } = await import('../src/cli/completion-resolver.js');
+    const candidates = resolveCompletionCandidates(['bash', '2', 'aop', 'status', 'summary']);
+    expect(candidates).toEqual([]);
+  });
 });