agentic-orchestrator 0.1.28 → 0.2.0

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

@@ -33,6 +33,7 @@ const getRuntimeSessionsMock = vi.hoisted(() =>
     feature_sessions: {},
   })),
 );
+const isRunLeaseFreshMock = vi.hoisted(() => vi.fn((_runtimeSessions?: unknown) => true));
 const featureDiscoverSpecsMock = vi.hoisted(() =>
   vi.fn(async () => ({
     data: {
@@ -57,6 +58,10 @@ const resolveProviderSelectionMock = vi.hoisted(() =>
     provider_config_ref: null,
   })),
 );
+const resolveProviderSelectionsByRoleMock = vi.hoisted(() => vi.fn(() => ({})));
+const validateRoleProviderCompatibilityMock = vi.hoisted(() =>
+  vi.fn(() => ({ valid: true, errors: [] })),
+);
 const supervisorConstructorOptionsMock = vi.hoisted(() => vi.fn());
 const supervisorStartMock = vi.hoisted(() =>
   vi.fn(async (..._args: unknown[]) => ({
@@ -109,6 +114,10 @@ vi.mock('../src/core/kernel.js', () => {
       return await getRuntimeSessionsMock();
     }
 
+    isRunLeaseFresh(runtimeSessions: { run_id?: string }) {
+      return isRunLeaseFreshMock(runtimeSessions);
+    }
+
     async featureDiscoverSpecs() {
       return await featureDiscoverSpecsMock();
     }
@@ -128,6 +137,8 @@ vi.mock('../src/mcp/runtime-factory.js', () => ({
 
 vi.mock('../src/providers/providers.js', () => ({
   resolveProviderSelection: resolveProviderSelectionMock,
+  resolveProviderSelectionsByRole: resolveProviderSelectionsByRoleMock,
+  validateRoleProviderCompatibility: validateRoleProviderCompatibilityMock,
   SUPPORTED_PROVIDERS: new Set(['codex', 'claude', 'gemini', 'custom', 'kiro-cli', 'copilot']),
   NullWorkerProvider: class NullWorkerProvider {
     selection: unknown;
@@ -171,6 +182,9 @@ vi.mock('../src/providers/worker-provider-factory.js', () => ({
   })),
   resolveMalformedWorkerOutputAction: vi.fn(() => 'block_feature'),
   resolveNoProgressAction: vi.fn(() => 'block_feature'),
+  resolvePromptOverlayDir: vi.fn(
+    (repoRoot: string) => `${repoRoot}/config/agentic/orchestrator/prompts/overrides`,
+  ),
 }));
 
 vi.mock('../src/supervisor/runtime.js', () => {
@@ -209,6 +223,7 @@ describe('aop CLI unit', () => {
     resolveToolClientMock.mockReset();
     resolveToolClientMock.mockReturnValue({ call: toolCallMock });
     toolCallMock.mockReset();
+    toolCallMock.mockResolvedValue({ ok: true, data: {} });
     ensureLoadedMock.mockReset();
     ensureLoadedMock.mockResolvedValue(undefined);
     recoverFromStateMock.mockReset();
@@ -232,6 +247,8 @@ describe('aop CLI unit', () => {
       owner_instance_id: 'owner:resume',
       feature_sessions: {},
     });
+    isRunLeaseFreshMock.mockReset();
+    isRunLeaseFreshMock.mockReturnValue(true);
     featureDiscoverSpecsMock.mockReset();
     featureDiscoverSpecsMock.mockResolvedValue({
       data: {
@@ -257,6 +274,8 @@ describe('aop CLI unit', () => {
       provider_config_env: null,
       provider_config_ref: null,
     });
+    validateRoleProviderCompatibilityMock.mockReset();
+    validateRoleProviderCompatibilityMock.mockReturnValue({ valid: true, errors: [] });
     supervisorConstructorOptionsMock.mockReset();
     supervisorStartMock.mockReset();
     supervisorStartMock.mockResolvedValue({
@@ -300,6 +319,81 @@ describe('aop CLI unit', () => {
     });
   });
 
+  it('GIVEN_project_flag_without_multi_project_config_WHEN_main_runs_THEN_returns_invalid_cli_args', async () => {
+    const code = await main(['status', '--project', 'alpha'], {
+      cwd,
+      env: {} as NodeJS.ProcessEnv,
+    });
+    const writes = asJsonWrites(stdoutSpy);
+
+    expect(code).toBe(1);
+    expect(writes[0]).toMatchObject({
+      ok: false,
+      error: {
+        code: ERROR_CODES.INVALID_CLI_ARGS,
+        details: {
+          project: 'alpha',
+        },
+      },
+    });
+  });
+
+  it('GIVEN_unknown_project_flag_WHEN_main_runs_THEN_returns_invalid_cli_args', async () => {
+    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.0"', 'projects:', '  - name: beta', '    path: ./beta'].join('\n'),
+      'utf8',
+    );
+
+    const code = await main(['status', '--project', 'alpha'], {
+      cwd,
+      env: {} as NodeJS.ProcessEnv,
+    });
+    const writes = asJsonWrites(stdoutSpy);
+
+    expect(code).toBe(1);
+    expect(writes[0]).toMatchObject({
+      ok: false,
+      error: {
+        code: ERROR_CODES.INVALID_CLI_ARGS,
+        details: {
+          project: 'alpha',
+          available: ['beta'],
+        },
+      },
+    });
+  });
+
+  it('GIVEN_malformed_git_file_WHEN_main_runs_THEN_falls_back_to_cwd_repo_root', async () => {
+    await fs.writeFile(path.join(cwd, '.git'), 'this is not a gitdir pointer', 'utf8');
+    toolCallMock.mockResolvedValue({ ok: true, data: { healthy: true } });
+
+    const code = await main(['status'], { cwd, env: {} as NodeJS.ProcessEnv });
+    const writes = asJsonWrites(stdoutSpy);
+
+    expect(code).toBe(0);
+    expect(createToolingRuntimeMock).toHaveBeenCalledWith(cwd, expect.any(Object));
+    expect(writes[0]).toMatchObject({ ok: true, data: { healthy: true } });
+  });
+
+  it('GIVEN_attach_provider_factory_returns_null_WHEN_main_runs_THEN_returns_internal_error', async () => {
+    const { DefaultWorkerProviderFactory } =
+      await import('../src/providers/worker-provider-factory.js');
+    vi.spyOn(DefaultWorkerProviderFactory.prototype, 'create').mockReturnValueOnce(null as never);
+
+    const code = await main(['attach', 'feature_resume'], { cwd, env: {} as NodeJS.ProcessEnv });
+    const writes = asJsonWrites(stdoutSpy);
+
+    expect(code).toBe(1);
+    expect(writes[0]).toMatchObject({
+      ok: false,
+      error: {
+        code: ERROR_CODES.INTERNAL_ERROR,
+      },
+    });
+  });
+
   it('GIVEN_status_command_WHEN_main_runs_THEN_calls_dashboard_and_returns_zero', async () => {
     toolCallMock.mockResolvedValue({ ok: true, data: { healthy: true } });
     const code = await main(['status'], { cwd, env: {} as NodeJS.ProcessEnv });
@@ -315,15 +409,242 @@ describe('aop CLI unit', () => {
     expect(writes[0]).toMatchObject({ ok: true, data: { healthy: true } });
   });
 
+  it('GIVEN_questions_command_WHEN_main_runs_THEN_lists_feature_questions', async () => {
+    toolCallMock.mockResolvedValue({
+      ok: true,
+      data: {
+        items: [{ question_id: 'q_1', status: 'open', prompt: 'Need approval' }],
+      },
+    });
+
+    const code = await main(['questions', '--feature-id', 'feature_resume', '--status', 'all'], {
+      cwd,
+      env: {} as NodeJS.ProcessEnv,
+    });
+    const writes = asJsonWrites(stdoutSpy);
+
+    expect(code).toBe(0);
+    expect(toolCallMock).toHaveBeenCalledWith(
+      TOOLS.FEATURE_QUESTION_LIST,
+      expect.objectContaining({
+        feature_id: 'feature_resume',
+        status: 'all',
+      }),
+      expect.objectContaining({ actor_type: 'system' }),
+    );
+    expect(writes[0]).toMatchObject({
+      ok: true,
+      data: {
+        command: 'questions',
+        feature_id: 'feature_resume',
+        status: 'all',
+        items: [{ question_id: 'q_1', status: 'open', prompt: 'Need approval' }],
+      },
+    });
+  });
+
+  it('GIVEN_answer_command_WHEN_main_runs_THEN_answers_the_question_and_returns_resume_state', async () => {
+    toolCallMock.mockResolvedValue({
+      ok: true,
+      data: {
+        question_id: 'q_1',
+        question_status: 'answered',
+        feature_status: 'building',
+        resumed: true,
+      },
+    });
+
+    const code = await main(
+      [
+        'answer',
+        '--feature-id',
+        'feature_resume',
+        '--question-id',
+        'q_1',
+        '--answer',
+        '{"decision":"approve"}',
+        '--answered-by',
+        'operator:alice',
+      ],
+      { cwd, env: {} as NodeJS.ProcessEnv },
+    );
+    const writes = asJsonWrites(stdoutSpy);
+
+    expect(code).toBe(0);
+    expect(toolCallMock).toHaveBeenCalledWith(
+      TOOLS.FEATURE_QUESTION_ANSWER,
+      expect.objectContaining({
+        feature_id: 'feature_resume',
+        question_id: 'q_1',
+        answer: { decision: 'approve' },
+        answered_by: 'operator:alice',
+      }),
+      expect.objectContaining({ actor_type: 'system' }),
+    );
+    expect(writes[0]).toMatchObject({
+      ok: true,
+      data: {
+        command: 'answer',
+        feature_id: 'feature_resume',
+        question_id: 'q_1',
+        question_status: 'answered',
+        feature_status: 'building',
+        resumed: true,
+      },
+    });
+  });
+
+  it('GIVEN_active_run_and_spec_WHEN_add_command_runs_THEN_submits_execution_request', async () => {
+    await fs.writeFile(path.join(cwd, 'feature_add.md'), '# Add\n\nSpec\n', 'utf8');
+    toolCallMock.mockResolvedValue({
+      ok: true,
+      data: {
+        run_id: 'run:resume',
+        request_id: 'exec_req_123',
+        request_status: 'pending',
+        requested_features: [
+          {
+            feature_id: 'feature_add',
+            spec_path: '.aop/features/feature_add/spec.md',
+          },
+        ],
+      },
+    });
+
+    const code = await main(['add', '-fi', 'feature_add.md'], {
+      cwd,
+      env: {} as NodeJS.ProcessEnv,
+    });
+    const writes = asJsonWrites(stdoutSpy);
+
+    expect(code).toBe(0);
+    expect(writes[0]).toMatchObject({
+      ok: true,
+      data: {
+        command: 'add',
+        run_id: 'run:resume',
+        request_id: 'exec_req_123',
+        request_status: 'pending',
+      },
+    });
+    expect(toolCallMock).toHaveBeenCalledWith(
+      TOOLS.RUNTIME_EXECUTION_REQUEST_SUBMIT,
+      expect.objectContaining({
+        run_id: 'run:resume',
+        owner_instance_id: 'owner:resume',
+        request_type: 'add_features',
+        features: [
+          {
+            feature_id: 'feature_add',
+            spec_path: '.aop/features/feature_add/spec.md',
+          },
+        ],
+      }),
+      expect.objectContaining({
+        actor_type: 'system',
+        actor_id: 'cli:system',
+      }),
+    );
+  });
+
+  it('GIVEN_active_run_and_resume_feature_WHEN_add_resume_runs_THEN_submits_execution_request_without_spec_ingestion', async () => {
+    toolCallMock.mockResolvedValue({
+      ok: true,
+      data: {
+        run_id: 'run:resume',
+        request_id: 'exec_req_resume_123',
+        request_status: 'pending',
+        requested_features: [
+          {
+            feature_id: 'feature_resume',
+            spec_path: '.aop/features/feature_resume/spec.md',
+          },
+        ],
+      },
+    });
+
+    const code = await main(['add', '--resume', 'feature_resume'], {
+      cwd,
+      env: {} as NodeJS.ProcessEnv,
+    });
+    const writes = asJsonWrites(stdoutSpy);
+
+    expect(code).toBe(0);
+    expect(featureStateGetMock).toHaveBeenCalledWith('feature_resume');
+    expect(toolCallMock).toHaveBeenCalledWith(
+      TOOLS.RUNTIME_EXECUTION_REQUEST_SUBMIT,
+      expect.objectContaining({
+        run_id: 'run:resume',
+        owner_instance_id: 'owner:resume',
+        request_type: 'add_features',
+        features: [
+          {
+            feature_id: 'feature_resume',
+            spec_path: '.aop/features/feature_resume/spec.md',
+          },
+        ],
+      }),
+      expect.objectContaining({
+        actor_type: 'system',
+        actor_id: 'cli:system',
+      }),
+    );
+    expect(writes[0]).toMatchObject({
+      ok: true,
+      data: {
+        command: 'add',
+        run_id: 'run:resume',
+        request_id: 'exec_req_resume_123',
+        request_status: 'pending',
+      },
+    });
+  });
+
+  it('GIVEN_terminal_resume_target_WHEN_add_resume_runs_THEN_returns_invalid_cli_args', async () => {
+    featureStateGetMock.mockResolvedValueOnce({
+      data: {
+        front_matter: {
+          status: STATUS.READY_TO_MERGE,
+        },
+      },
+    });
+
+    const code = await main(['add', '--resume', 'feature_resume'], {
+      cwd,
+      env: {} as NodeJS.ProcessEnv,
+    });
+    const writes = asJsonWrites(stdoutSpy);
+
+    expect(code).toBe(1);
+    expect(toolCallMock).not.toHaveBeenCalledWith(
+      TOOLS.RUNTIME_EXECUTION_REQUEST_SUBMIT,
+      expect.anything(),
+      expect.anything(),
+    );
+    expect(writes[0]).toMatchObject({
+      ok: false,
+      error: {
+        code: ERROR_CODES.INVALID_CLI_ARGS,
+        details: expect.objectContaining({
+          reason: 'feature_not_resumable',
+          feature_id: 'feature_resume',
+          status: STATUS.READY_TO_MERGE,
+        }),
+      },
+    });
+  });
+
   it('GIVEN_resume_command_WHEN_main_runs_THEN_resumes_non_terminal_features_from_persisted_state', async () => {
     recoverFromStateMock.mockResolvedValue({
       data: { recovered: true, stale_features: ['f1'], active: {} },
     });
-    supervisorStartMock.mockResolvedValue({
-      queue_depth: 0,
-      status: 'running',
-      run_metadata: { resumed: true },
-      dashboard: { features: ['feature_resume'] },
+    toolCallMock.mockResolvedValue({
+      ok: true,
+      data: {
+        run_id: 'run:resume',
+        request_id: 'exec_req_resume_001',
+        request_status: 'pending',
+      },
     });
     const code = await main(['resume'], { cwd, env: {} as NodeJS.ProcessEnv });
     const writes = asJsonWrites(stdoutSpy);
@@ -332,15 +653,15 @@ describe('aop CLI unit', () => {
     expect(recoverFromStateMock).toHaveBeenCalledTimes(1);
     expect(featureDiscoverSpecsMock).toHaveBeenCalledTimes(1);
     expect(featureStateGetMock).toHaveBeenCalledWith('feature_resume');
-    expect(supervisorStartMock).toHaveBeenCalledWith(
-      [{ feature_id: 'feature_resume' }],
-      expect.any(Object),
-    );
+    expect(supervisorStartMock).not.toHaveBeenCalled();
     expect(writes[0]).toMatchObject({
       ok: true,
       data: {
         command: 'resume',
         resumed: true,
+        resume_mode: 'active_run_enrollment',
+        request_id: 'exec_req_resume_001',
+        request_status: 'pending',
         resumed_features: [
           expect.objectContaining({
             feature_id: 'feature_resume',
@@ -644,6 +965,249 @@ describe('aop CLI unit', () => {
     );
   });
 
+  it('GIVEN_invalid_role_provider_compatibility_WHEN_run_command_THEN_returns_error', async () => {
+    const incoming = path.join(cwd, 'incoming');
+    await fs.mkdir(incoming, { recursive: true });
+    await fs.writeFile(path.join(incoming, 'feature_compat.md'), '# Spec\n\nBuild.\n', 'utf8');
+
+    toolCallMock.mockImplementation(async (toolName: string) => {
+      if (toolName === TOOLS.FEATURE_STATE_GET) {
+        return { ok: true, data: { front_matter: { version: 1 } } };
+      }
+      return { ok: true, data: {} };
+    });
+
+    validateRoleProviderCompatibilityMock.mockReturnValue({
+      valid: false,
+      errors: [
+        {
+          code: ERROR_CODES.UNSUPPORTED_AGENT_PROVIDER,
+          message: 'Provider "bad" is not supported for role builder',
+          details: { retryable: false },
+          role: 'builder',
+        },
+      ],
+    });
+
+    const code = await main(
+      ['run', '-fi', path.join('incoming', 'feature_compat.md'), '--agent-provider', 'codex'],
+      { cwd, env: {} as NodeJS.ProcessEnv },
+    );
+    const writes = asJsonWrites(stdoutSpy);
+
+    expect(code).toBe(1);
+    expect(writes[0]).toMatchObject({
+      ok: false,
+      error: expect.objectContaining({
+        code: ERROR_CODES.UNSUPPORTED_AGENT_PROVIDER,
+      }),
+    });
+  });
+
+  it('GIVEN_active_run_WHEN_retry_reroutes_at_same_phase_THEN_triggers_auto_resume', async () => {
+    toolCallMock.mockImplementation(async (toolName: string) => {
+      if (toolName === TOOLS.FEATURE_STATE_GET) {
+        return { ok: true, data: { front_matter: { version: 5, status: 'qa' } } };
+      }
+      return { ok: true, data: {} };
+    });
+
+    const code = await main(['retry', '--feature-id', 'feature_resume'], {
+      cwd,
+      env: {} as NodeJS.ProcessEnv,
+    });
+    const writes = asJsonWrites(stdoutSpy);
+
+    expect(code).toBe(0);
+    expect(writes[0]).toMatchObject({
+      ok: true,
+      data: {
+        retry: {
+          feature_id: 'feature_resume',
+          retry_count_reset: true,
+          retry_executed: false,
+          reroute_status: 'qa',
+        },
+        auto_resume: {
+          attempted: true,
+        },
+      },
+    });
+  });
+
+  it('GIVEN_merge_gate_fails_after_reconciliation_and_feature_has_no_cluster_WHEN_merge_runs_THEN_reenrolls_via_add', async () => {
+    featureStateGetMock.mockResolvedValue({
+      data: {
+        front_matter: {
+          status: STATUS.BLOCKED,
+        },
+      },
+    });
+    toolCallMock.mockImplementation(async (toolName: string) => {
+      if (toolName === TOOLS.FEATURE_STATE_GET) {
+        return {
+          ok: true,
+          data: { front_matter: { version: 5, status: STATUS.READY_TO_MERGE, gates: {} } },
+        };
+      }
+      if (toolName === TOOLS.REPO_RECONCILE_MAINLINE) {
+        return { ok: true, data: { status: 'merged' } };
+      }
+      if (toolName === TOOLS.GATES_RUN) {
+        return { ok: true, data: { overall: 'fail' } };
+      }
+      if (toolName === TOOLS.RUNTIME_EXECUTION_REQUEST_SUBMIT) {
+        return {
+          ok: true,
+          data: {
+            run_id: 'run:resume',
+            request_id: 'exec_req_merge_001',
+            request_status: 'pending',
+            requested_features: [
+              {
+                feature_id: 'feature_resume',
+                spec_path: '.aop/features/feature_resume/spec.md',
+              },
+            ],
+          },
+        };
+      }
+      return { ok: true, data: {} };
+    });
+
+    const code = await main(['merge', '--feature-id', 'feature_resume'], {
+      cwd,
+      env: {} as NodeJS.ProcessEnv,
+    });
+    const writes = asJsonWrites(stdoutSpy);
+
+    expect(code).toBe(0);
+    expect(toolCallMock).toHaveBeenCalledWith(
+      TOOLS.RUNTIME_EXECUTION_REQUEST_SUBMIT,
+      expect.objectContaining({
+        run_id: 'run:resume',
+        owner_instance_id: 'owner:resume',
+        request_type: 'add_features',
+        features: [
+          {
+            feature_id: 'feature_resume',
+            spec_path: '.aop/features/feature_resume/spec.md',
+          },
+        ],
+      }),
+      expect.any(Object),
+    );
+    expect(writes[0]).toMatchObject({
+      ok: true,
+      data: {
+        merge: {
+          ok: false,
+          error: {
+            code: ERROR_CODES.MERGE_DISABLED,
+            details: expect.objectContaining({
+              feature_id: 'feature_resume',
+              reconciliation_attempted: true,
+            }),
+          },
+        },
+        auto_resume: {
+          attempted: true,
+          ok: true,
+          data: {
+            command: 'resume',
+            request_id: 'exec_req_merge_001',
+          },
+        },
+      },
+    });
+  });
+
+  it('GIVEN_merge_gate_fails_after_reconciliation_and_feature_has_cluster_WHEN_merge_runs_THEN_returns_already_enrolled_resume_state', async () => {
+    getRuntimeSessionsMock.mockResolvedValue({
+      run_id: 'run:resume',
+      owner_instance_id: 'owner:resume',
+      feature_sessions: {
+        feature_resume: {
+          planner_session_id: 'planner-session',
+          builder_session_id: 'builder-session',
+          qa_session_id: 'qa-session',
+        },
+      },
+    });
+    readIndexMock.mockResolvedValue({
+      version: 1,
+      active: ['feature_resume'],
+      blocked: ['feature_resume'],
+      blocked_queue: [],
+    });
+    featureDiscoverSpecsMock.mockResolvedValue({
+      data: {
+        specs: [
+          { feature_id: 'feature_resume', spec_path: '.aop/features/feature_resume/spec.md' },
+        ],
+      },
+    });
+    featureStateGetMock.mockResolvedValue({
+      data: {
+        front_matter: {
+          status: STATUS.BLOCKED,
+        },
+      },
+    });
+    toolCallMock.mockImplementation(async (toolName: string) => {
+      if (toolName === TOOLS.FEATURE_STATE_GET) {
+        return {
+          ok: true,
+          data: { front_matter: { version: 5, status: STATUS.READY_TO_MERGE, gates: {} } },
+        };
+      }
+      if (toolName === TOOLS.REPO_RECONCILE_MAINLINE) {
+        return { ok: true, data: { status: 'merged' } };
+      }
+      if (toolName === TOOLS.GATES_RUN) {
+        return { ok: true, data: { overall: 'fail' } };
+      }
+      return { ok: true, data: {} };
+    });
+
+    const code = await main(['merge', '--feature-id', 'feature_resume'], {
+      cwd,
+      env: {} as NodeJS.ProcessEnv,
+    });
+    const writes = asJsonWrites(stdoutSpy);
+
+    expect(code).toBe(0);
+    expect(toolCallMock).not.toHaveBeenCalledWith(
+      TOOLS.RUNTIME_EXECUTION_REQUEST_SUBMIT,
+      expect.anything(),
+      expect.anything(),
+    );
+    expect(supervisorStartMock).not.toHaveBeenCalled();
+    expect(writes[0]).toMatchObject({
+      ok: true,
+      data: {
+        merge: {
+          ok: false,
+          error: {
+            code: ERROR_CODES.MERGE_DISABLED,
+          },
+        },
+        auto_resume: {
+          attempted: true,
+          ok: true,
+          data: {
+            command: 'resume',
+            resumed: true,
+            resume_mode: 'already_enrolled',
+            request_id: null,
+            already_enrolled_features: ['feature_resume'],
+            resumed_features: [expect.objectContaining({ feature_id: 'feature_resume' })],
+          },
+        },
+      },
+    });
+  });
+
   it('GIVEN_stale_takeover_contract_WHEN_run_without_and_with_flag_THEN_returns_run_already_active_then_succeeds', async () => {
     const incoming = path.join(cwd, 'incoming');
     await fs.mkdir(incoming, { recursive: true });
@@ -795,19 +1359,14 @@ describe('aop CLI unit', () => {
     });
   });
 
-  it('GIVEN_resume_with_READY_TO_MERGE_status_WHEN_main_runs_THEN_resumes_in_ready_to_merge_phase', async () => {
+  it('GIVEN_resume_with_READY_TO_MERGE_status_WHEN_main_runs_THEN_filters_feature_and_returns_resumed_false', async () => {
     featureStateGetMock.mockResolvedValue({
       data: { front_matter: { status: STATUS.READY_TO_MERGE } },
     });
     const code = await main(['resume'], { cwd, env: {} as NodeJS.ProcessEnv });
     const writes = asJsonWrites(stdoutSpy);
     expect(code).toBe(0);
-    expect(writes[0]).toMatchObject({
-      ok: true,
-      data: {
-        resumed_features: [expect.objectContaining({ resume_phase: STATUS.READY_TO_MERGE })],
-      },
-    });
+    expect(writes[0]).toMatchObject({ ok: true, data: { resumed: false } });
   });
 
   it('GIVEN_feature_with_MERGED_status_WHEN_resume_runs_THEN_filters_terminal_feature_and_returns_resumed_false', async () => {
@@ -984,4 +1543,226 @@ describe('aop CLI unit', () => {
     expect(code).toBe(0);
     expect(writes[0]).toMatchObject({ ok: true, data: { command: 'batch-run', failed: 1 } });
   });
+
+  it('GIVEN_batch_mode_with_invalid_feature_id_WHEN_run_command_THEN_counts_as_failed', async () => {
+    const incoming = path.join(cwd, 'batch_folder4');
+    await fs.mkdir(incoming, { recursive: true });
+    // File whose name (after stripping extension) is not a valid feature ID
+    await fs.writeFile(path.join(incoming, '!!!.md'), '# Invalid\n', 'utf8');
+
+    toolCallMock.mockResolvedValue({ ok: true, data: {} });
+
+    const code = await main(['run', '-fl', 'batch_folder4', '--batch'], {
+      cwd,
+      env: {} as NodeJS.ProcessEnv,
+    });
+    const writes = asJsonWrites(stdoutSpy);
+    expect(code).toBe(0);
+    expect(writes[0]).toMatchObject({
+      ok: true,
+      data: { command: 'batch-run', failed: 1 },
+    });
+    expect(writes[0].data.details[0]).toMatchObject({
+      status: 'failed',
+      reason: 'invalid feature id',
+    });
+  });
+});
+
+describe('aop CLI completion command', () => {
+  let cwd: string;
+  let stdoutSpy: ReturnType<typeof vi.spyOn>;
+
+  beforeEach(async () => {
+    cwd = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-completion-'));
+    stdoutSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
+  });
+
+  afterEach(async () => {
+    stdoutSpy.mockRestore();
+    vi.restoreAllMocks();
+    await fs.rm(cwd, { recursive: true, force: true });
+  });
+
+  it('GIVEN_completion_bash_WHEN_main_runs_THEN_exits_0_and_writes_script', async () => {
+    const code = await main(['completion', 'bash'], { cwd, env: {} as NodeJS.ProcessEnv });
+    expect(code).toBe(0);
+    const written = (stdoutSpy.mock.calls as unknown[][]).map((c) => String(c[0])).join('');
+    expect(written).toContain('_aop_completion');
+    expect(written).toContain('aop __complete bash "$COMP_CWORD" "${COMP_WORDS[@]:1}"');
+  });
+
+  it('GIVEN_completion_zsh_WHEN_main_runs_THEN_exits_0_and_writes_script', async () => {
+    const code = await main(['completion', 'zsh'], { cwd, env: {} as NodeJS.ProcessEnv });
+    expect(code).toBe(0);
+    const written = (stdoutSpy.mock.calls as unknown[][]).map((c) => String(c[0])).join('');
+    expect(written).toContain('aop __complete zsh "$CURRENT" "${words[@]:2}"');
+    expect(written).toContain('compdef _aop_completion aop');
+  });
+
+  it('GIVEN_completion_fish_WHEN_main_runs_THEN_exits_0_and_writes_script', async () => {
+    const code = await main(['completion', 'fish'], { cwd, env: {} as NodeJS.ProcessEnv });
+    expect(code).toBe(0);
+    const written = (stdoutSpy.mock.calls as unknown[][]).map((c) => String(c[0])).join('');
+    expect(written).toContain('complete -c aop');
+  });
+
+  it('GIVEN_completion_unsupported_shell_WHEN_main_runs_THEN_exits_1_with_invalid_cli_args', async () => {
+    const code = await main(['completion', 'powershell'], { cwd, env: {} as NodeJS.ProcessEnv });
+    const writes = (stdoutSpy.mock.calls as unknown[][]).map((c) => String(c[0])).join('');
+    const parsed = JSON.parse(writes.trim()) as { ok: boolean; error: { code: string } };
+    expect(code).toBe(1);
+    expect(parsed).toMatchObject({ ok: false, error: { code: ERROR_CODES.INVALID_CLI_ARGS } });
+  });
+
+  it('GIVEN_completion_no_shell_WHEN_main_runs_THEN_exits_1_with_invalid_cli_args', async () => {
+    const code = await main(['completion'], { cwd, env: {} as NodeJS.ProcessEnv });
+    expect(code).toBe(1);
+    const writes = (stdoutSpy.mock.calls as unknown[][]).map((c) => String(c[0])).join('');
+    const parsed = JSON.parse(writes.trim()) as { ok: boolean; error: { code: string } };
+    expect(parsed).toMatchObject({ ok: false, error: { code: ERROR_CODES.INVALID_CLI_ARGS } });
+  });
+
+  it('GIVEN_internal_complete_with_no_args_WHEN_main_runs_THEN_exits_0_and_emits_nothing', async () => {
+    const code = await main(['__complete'], { cwd, env: {} as NodeJS.ProcessEnv });
+    expect(code).toBe(0);
+    const written = (stdoutSpy.mock.calls as unknown[][]).map((c) => String(c[0])).join('');
+    expect(written).toBe('');
+  });
+
+  it('GIVEN_internal_complete_with_aop_prefix_WHEN_main_runs_THEN_exits_0_and_emits_commands', async () => {
+    const code = await main(['__complete', 'bash', '0', 'aop'], {
+      cwd,
+      env: {} as NodeJS.ProcessEnv,
+    });
+    expect(code).toBe(0);
+    const written = (stdoutSpy.mock.calls as unknown[][]).map((c) => String(c[0])).join('');
+    expect(written).toContain('status');
+    expect(written).toContain('run');
+  });
+
+  it('GIVEN_internal_complete_with_status_command_WHEN_main_runs_THEN_exits_0_and_emits_flags', async () => {
+    const code = await main(['__complete', 'bash', '2', 'aop', 'status', '--'], {
+      cwd,
+      env: {} as NodeJS.ProcessEnv,
+    });
+    expect(code).toBe(0);
+    const written = (stdoutSpy.mock.calls as unknown[][]).map((c) => String(c[0])).join('');
+    expect(written).toContain('--summary');
+  });
+
+  it('GIVEN_internal_complete_legacy_backend_args_WHEN_main_runs_THEN_exits_0_and_emits_flags', async () => {
+    const code = await main(['__complete', '--', 'aop', 'status', '--'], {
+      cwd,
+      env: {} as NodeJS.ProcessEnv,
+    });
+    expect(code).toBe(0);
+    const written = (stdoutSpy.mock.calls as unknown[][]).map((c) => String(c[0])).join('');
+    expect(written).toContain('--summary');
+    expect(written).toContain('--project');
+  });
+
+  it('GIVEN_internal_complete_malformed_WHEN_main_runs_THEN_always_exits_0', async () => {
+    const code = await main(['__complete', 'bogus'], { cwd, env: {} as NodeJS.ProcessEnv });
+    expect(code).toBe(0);
+  });
+});
+
+describe('aop CLI replay command', () => {
+  let cwd: string;
+  let stdoutSpy: ReturnType<typeof vi.spyOn>;
+
+  beforeEach(async () => {
+    cwd = await fs.mkdtemp(path.join(os.tmpdir(), 'aop-replay-cli-'));
+    await fs.mkdir(path.join(cwd, 'config', 'agentic', 'orchestrator'), { recursive: true });
+    stdoutSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
+    vi.spyOn(process.stderr, 'write').mockImplementation(() => true);
+    toolCallMock.mockReset();
+  });
+
+  afterEach(async () => {
+    vi.restoreAllMocks();
+    await fs.rm(cwd, { recursive: true, force: true });
+  });
+
+  it('GIVEN_replay_command_with_run_id_WHEN_executed_THEN_calls_replay_timeline_get', async () => {
+    toolCallMock.mockResolvedValue({
+      ok: true,
+      data: { run_id: 'run-cli-001', entries: [], total: 0 },
+    });
+
+    const code = await main(['replay', '--run-id', 'run-cli-001'], {
+      cwd,
+      env: {} as NodeJS.ProcessEnv,
+    });
+
+    expect(code).toBe(0);
+    expect(toolCallMock).toHaveBeenCalledWith(
+      'replay.timeline_get',
+      expect.objectContaining({ run_id: 'run-cli-001' }),
+      expect.any(Object),
+    );
+  });
+
+  it('GIVEN_replay_command_without_run_id_WHEN_executed_THEN_returns_nonzero_exit_code', async () => {
+    const code = await main(['replay'], {
+      cwd,
+      env: {} as NodeJS.ProcessEnv,
+    });
+
+    expect(code).not.toBe(0);
+  });
+
+  it('GIVEN_replay_command_with_json_flag_WHEN_executed_THEN_emits_json_response', async () => {
+    toolCallMock.mockResolvedValue({
+      ok: true,
+      data: { run_id: 'run-cli-002', entries: [], total: 0 },
+    });
+
+    const code = await main(['replay', '--run-id', 'run-cli-002', '--json'], {
+      cwd,
+      env: {} as NodeJS.ProcessEnv,
+    });
+
+    expect(code).toBe(0);
+    const written = (stdoutSpy.mock.calls as unknown[][]).map((c) => String(c[0])).join('');
+    const parsed = JSON.parse(written) as { run_id: string };
+    expect(parsed.run_id).toBe('run-cli-002');
+  });
+
+  it('GIVEN_replay_command_with_filters_WHEN_executed_THEN_passes_filters_to_tool', async () => {
+    toolCallMock.mockResolvedValue({
+      ok: true,
+      data: { run_id: 'run-cli-003', entries: [], total: 0 },
+    });
+
+    await main(
+      [
+        'replay',
+        '--run-id',
+        'run-cli-003',
+        '--from-sequence',
+        '5',
+        '--limit',
+        '10',
+        '--feature-id',
+        'feat_x',
+        '--tool',
+        'repo.apply_patch',
+      ],
+      { cwd, env: {} as NodeJS.ProcessEnv },
+    );
+
+    expect(toolCallMock).toHaveBeenCalledWith(
+      'replay.timeline_get',
+      expect.objectContaining({
+        run_id: 'run-cli-003',
+        from_sequence: 5,
+        limit: 10,
+        feature_id: 'feat_x',
+        tool_name: 'repo.apply_patch',
+      }),
+      expect.any(Object),
+    );
+  });
 });