agentic-orchestrator 0.1.28 → 0.2.1

package/apps/control-plane/test/merge-service.spec.ts

@@ -38,9 +38,10 @@ function makeHarness(
   options: {
     stateOverrides?: AnyRecord;
     policyOverrides?: AnyRecord;
+    indexOverrides?: AnyRecord;
   } = {},
 ) {
-  const state = {
+  const state: { frontMatter: AnyRecord; body: string } = {
     frontMatter: {
       feature_id: 'feature_merge',
       version: 3,
@@ -77,6 +78,8 @@ function makeHarness(
     blocked: ['feature_merge'],
     merged: [],
     blocked_queue: [{ feature_id: 'feature_merge' }, { feature_id: 'other' }],
+    locks: {},
+    lock_leases: {},
     runtime_sessions: {
       feature_sessions: {
         feature_merge: {
@@ -91,15 +94,33 @@ function makeHarness(
         },
       },
     },
+    ...(options.indexOverrides ?? {}),
   };
 
   const locksRelease = vi.fn(async () => ({ data: { released: true } }));
+  const gatesRun = vi.fn(async (_featureId: string, _profileName: string | null, mode: string) => {
+    state.frontMatter = {
+      ...state.frontMatter,
+      gates: {
+        ...(state.frontMatter.gates as AnyRecord),
+        [mode]: GATE_RESULT.PASS,
+      },
+    };
+    return {
+      data: {
+        feature_id: 'feature_merge',
+        mode,
+        overall: GATE_RESULT.PASS,
+      },
+    };
+  });
 
   const service = new MergeService({
     getRepoRoot: () => '/repo',
     getPolicySnapshot: () => clone(policy),
     featurePath: (featureId: string) => `/repo/.aop/features/${featureId}`,
     readState: async () => clone(state),
+    gatesRun,
     worktreePath: (featureId: string) => `/repo/.worktrees/${featureId}`,
     updateState: async (_featureId: string, expectedVersion: number | null, updater: any) => {
       if (expectedVersion != null && expectedVersion !== state.frontMatter.version) {
@@ -125,6 +146,7 @@ function makeHarness(
   return {
     service,
     state,
+    gatesRun,
     locksRelease,
     getIndex: () => clone(index),
   };
@@ -180,7 +202,7 @@ describe('MergeService', () => {
     expect(runGit).not.toHaveBeenCalled();
   });
 
-  it('GIVEN_feature_not_ready_or_required_gates_missing_WHEN_feature_ready_to_merge_THEN_returns_precondition_errors', async () => {
+  it('GIVEN_feature_not_ready_or_required_gates_missing_without_merge_verification_WHEN_feature_ready_to_merge_THEN_returns_precondition_errors', async () => {
     const invalidStatus = makeHarness({
       stateOverrides: {
         status: STATUS.BUILDING,
@@ -204,7 +226,7 @@ describe('MergeService', () => {
     const missingGate = makeHarness({
       stateOverrides: {
         gates: {
-          fast: GATE_RESULT.PASS,
+          fast: GATE_RESULT.FAIL,
           full: GATE_RESULT.FAIL,
         },
       },
@@ -216,11 +238,49 @@ describe('MergeService', () => {
         error: {
           code: ERROR_CODES.MERGE_DISABLED,
           details: {
-            mode: 'full',
+            mode: 'fast',
           },
         },
       },
     });
+    expect(missingGate.gatesRun).not.toHaveBeenCalled();
+  });
+
+  it('GIVEN_merge_gate_passed_with_missing_prerequisite_gates_WHEN_feature_ready_to_merge_THEN_reruns_prerequisites_before_merging', async () => {
+    const harness = makeHarness({
+      stateOverrides: {
+        gates: {
+          fast: GATE_RESULT.FAIL,
+          full: GATE_RESULT.FAIL,
+          merge: GATE_RESULT.PASS,
+        },
+      },
+    });
+    vi.mocked(runGit)
+      .mockResolvedValueOnce(commandResult()) // add -A
+      .mockResolvedValueOnce(commandResult()) // commit
+      .mockResolvedValueOnce(commandResult({ stdout: '1\n' })) // rev-list ahead count
+      .mockResolvedValueOnce(commandResult()) // status
+      .mockResolvedValueOnce(commandResult()) // checkout main
+      .mockResolvedValueOnce(commandResult()) // merge
+      .mockResolvedValueOnce(commandResult({ stdout: 'abc123\n' })); // rev-parse
+
+    const result = await harness.service.featureReadyToMerge(
+      'feature_merge',
+      'merge',
+      'merge_commit',
+      'approved',
+    );
+
+    expect(harness.gatesRun).toHaveBeenNthCalledWith(1, 'feature_merge', null, 'fast');
+    expect(harness.gatesRun).toHaveBeenNthCalledWith(2, 'feature_merge', null, 'full');
+    expect(harness.state.frontMatter.gates).toMatchObject({
+      fast: GATE_RESULT.PASS,
+      full: GATE_RESULT.PASS,
+      merge: GATE_RESULT.PASS,
+    });
+    expect(result.data.merge_sha).toBe('abc123');
+    expect(result.data.status).toBe(STATUS.MERGED);
   });
 
   it('GIVEN_git_add_or_commit_failures_WHEN_feature_ready_to_merge_THEN_returns_git_failure_error', async () => {
@@ -258,11 +318,146 @@ describe('MergeService', () => {
     });
   });
 
+  it('GIVEN_statusCheck_only_ignored_paths_WHEN_feature_ready_to_merge_THEN_allows_merge', async () => {
+    const harness = makeHarness();
+    vi.mocked(runGit)
+      .mockResolvedValueOnce(commandResult()) // add -A
+      .mockResolvedValueOnce(commandResult()) // commit
+      .mockResolvedValueOnce(commandResult({ stdout: '1\n' })) // rev-list ahead count
+      .mockResolvedValueOnce(
+        commandResult({
+          stdout: [
+            ' M .aop/features/index.json',
+            ' M .worktrees/feature_merge/README.md',
+            ' M agentic/orchestrator/tools.md',
+          ].join('\n'),
+        }),
+      ) // status
+      .mockResolvedValueOnce(commandResult()) // checkout main
+      .mockResolvedValueOnce(commandResult()) // merge
+      .mockResolvedValueOnce(commandResult({ stdout: 'abc123\n' })); // rev-parse
+
+    const result = await harness.service.featureReadyToMerge(
+      'feature_merge',
+      'merge',
+      'merge_commit',
+      'approved',
+    );
+
+    expect(result.data.merge_sha).toBe('abc123');
+    expect(result.data.status).toBe(STATUS.MERGED);
+  });
+
+  it('GIVEN_feature_branch_without_unique_commits_WHEN_feature_ready_to_merge_THEN_returns_merge_no_changes', async () => {
+    const harness = makeHarness();
+    vi.mocked(runGit)
+      .mockResolvedValueOnce(commandResult()) // add -A
+      .mockResolvedValueOnce(commandResult({ stdout: 'nothing to commit' })) // commit
+      .mockResolvedValueOnce(commandResult({ stdout: '0\n' })); // rev-list ahead count
+
+    await expect(
+      harness.service.featureReadyToMerge('feature_merge', 'merge', 'merge_commit', 'approved'),
+    ).rejects.toMatchObject({
+      normalizedResponse: {
+        error: {
+          code: ERROR_CODES.MERGE_NO_CHANGES,
+        },
+      },
+    });
+  });
+
+  it('GIVEN_statusCheck_dirty_files_WHEN_resolveConflicts_false_THEN_returns_uncommitted_changes', async () => {
+    const harness = makeHarness();
+    vi.mocked(runGit)
+      .mockResolvedValueOnce(commandResult()) // add -A
+      .mockResolvedValueOnce(commandResult()) // commit
+      .mockResolvedValueOnce(commandResult({ stdout: '1\n' })) // rev-list ahead count
+      .mockResolvedValueOnce(commandResult({ stdout: ' M src/dirty.txt\n' })); // status
+
+    await expect(
+      harness.service.featureReadyToMerge('feature_merge', 'merge', 'merge_commit', 'approved'),
+    ).rejects.toMatchObject({
+      normalizedResponse: { error: { code: ERROR_CODES.UNCOMMITTED_CHANGES } },
+    });
+  });
+
+  it('GIVEN_statusCheck_dirty_files_WHEN_resolveConflicts_true_and_stage_fails_THEN_returns_git_failure', async () => {
+    const harness = makeHarness();
+    vi.mocked(runGit)
+      .mockResolvedValueOnce(commandResult()) // add -A
+      .mockResolvedValueOnce(commandResult()) // commit
+      .mockResolvedValueOnce(commandResult({ stdout: '1\n' })) // rev-list ahead count
+      .mockResolvedValueOnce(commandResult({ stdout: ' M src/dirty.txt\n' })) // status
+      .mockResolvedValueOnce(commandResult({ code: 1, stderr: 'stage failed' })); // stage -A
+
+    await expect(
+      harness.service.featureReadyToMerge(
+        'feature_merge',
+        'merge',
+        'merge_commit',
+        'approved',
+        true,
+      ),
+    ).rejects.toMatchObject({
+      normalizedResponse: { error: { code: ERROR_CODES.GIT_FAILURE } },
+    });
+  });
+
+  it('GIVEN_statusCheck_dirty_files_WHEN_resolveConflicts_true_and_commit_fails_THEN_returns_git_failure', async () => {
+    const harness = makeHarness();
+    vi.mocked(runGit)
+      .mockResolvedValueOnce(commandResult()) // add -A
+      .mockResolvedValueOnce(commandResult()) // commit
+      .mockResolvedValueOnce(commandResult({ stdout: '1\n' })) // rev-list ahead count
+      .mockResolvedValueOnce(commandResult({ stdout: ' M src/dirty.txt\n' })) // status
+      .mockResolvedValueOnce(commandResult()) // stage -A
+      .mockResolvedValueOnce(commandResult({ code: 1, stderr: 'commit failed' })); // commit
+
+    await expect(
+      harness.service.featureReadyToMerge(
+        'feature_merge',
+        'merge',
+        'merge_commit',
+        'approved',
+        true,
+      ),
+    ).rejects.toMatchObject({
+      normalizedResponse: { error: { code: ERROR_CODES.GIT_FAILURE } },
+    });
+  });
+
+  it('GIVEN_statusCheck_dirty_files_WHEN_resolveConflicts_true_THEN_commits_and_merges', async () => {
+    const harness = makeHarness();
+    vi.mocked(runGit)
+      .mockResolvedValueOnce(commandResult()) // add -A
+      .mockResolvedValueOnce(commandResult()) // commit
+      .mockResolvedValueOnce(commandResult({ stdout: '1\n' })) // rev-list ahead count
+      .mockResolvedValueOnce(commandResult({ stdout: ' M src/dirty.txt\n' })) // status
+      .mockResolvedValueOnce(commandResult()) // stage -A
+      .mockResolvedValueOnce(commandResult()) // commit uncommitted
+      .mockResolvedValueOnce(commandResult()) // checkout main
+      .mockResolvedValueOnce(commandResult()) // merge
+      .mockResolvedValueOnce(commandResult({ stdout: 'abc123\n' })); // rev-parse
+
+    const result = await harness.service.featureReadyToMerge(
+      'feature_merge',
+      'merge',
+      'merge_commit',
+      'approved',
+      true,
+    );
+
+    expect(result.data.merge_sha).toBe('abc123');
+    expect(result.data.status).toBe(STATUS.MERGED);
+  });
+
   it('GIVEN_checkout_or_rebase_failures_WHEN_feature_ready_to_merge_THEN_returns_human_required_git_failure', async () => {
     const checkoutFailure = makeHarness();
     vi.mocked(runGit)
       .mockResolvedValueOnce(commandResult())
       .mockResolvedValueOnce(commandResult({ code: 1, stderr: 'nothing to commit' }))
+      .mockResolvedValueOnce(commandResult({ stdout: '1\n' }))
+      .mockResolvedValueOnce(commandResult())
       .mockResolvedValueOnce(commandResult({ code: 1, stderr: 'checkout failed' }));
 
     await expect(
@@ -287,6 +482,8 @@ describe('MergeService', () => {
     vi.mocked(runGit)
       .mockResolvedValueOnce(commandResult())
       .mockResolvedValueOnce(commandResult())
+      .mockResolvedValueOnce(commandResult({ stdout: '1\n' }))
+      .mockResolvedValueOnce(commandResult())
       .mockResolvedValueOnce(commandResult())
       .mockResolvedValueOnce(commandResult({ code: 1, stderr: 'rebase failed' }));
 
@@ -309,6 +506,8 @@ describe('MergeService', () => {
     vi.mocked(runGit)
       .mockResolvedValueOnce(commandResult())
       .mockResolvedValueOnce(commandResult({ code: 1, stderr: 'nothing to commit' }))
+      .mockResolvedValueOnce(commandResult({ stdout: '1\n' }))
+      .mockResolvedValueOnce(commandResult())
       .mockResolvedValueOnce(commandResult())
       .mockResolvedValueOnce(commandResult())
       .mockResolvedValueOnce(commandResult({ code: 1, stderr: 'squash commit failed' }));
@@ -334,11 +533,29 @@ describe('MergeService', () => {
           held: ['openapi', 42],
         },
       },
+      indexOverrides: {
+        locks: {
+          openapi: 'feature_merge',
+          docs: 'other',
+        },
+        lock_leases: {
+          openapi: {
+            holder: 'feature_merge',
+            leased_at: '2026-03-05T00:00:00.000Z',
+          },
+          docs: {
+            holder: 'other',
+            leased_at: '2026-03-05T00:00:00.000Z',
+          },
+        },
+      },
     });
 
     vi.mocked(runGit)
       .mockResolvedValueOnce(commandResult())
       .mockResolvedValueOnce(commandResult())
+      .mockResolvedValueOnce(commandResult({ stdout: '1\n' }))
+      .mockResolvedValueOnce(commandResult())
       .mockResolvedValueOnce(commandResult())
       .mockResolvedValueOnce(commandResult())
       .mockResolvedValueOnce(commandResult())
@@ -368,6 +585,16 @@ describe('MergeService', () => {
     expect(index.blocked).toEqual([]);
     expect(index.merged).toEqual(['feature_merge']);
     expect(index.blocked_queue).toEqual([{ feature_id: 'other' }]);
+    expect(index.locks).toMatchObject({
+      openapi: null,
+      docs: 'other',
+    });
+    expect(index.lock_leases).toMatchObject({
+      openapi: null,
+      docs: {
+        holder: 'other',
+      },
+    });
     expect(index.runtime_sessions.feature_sessions).not.toHaveProperty('feature_merge');
     expect(index.runtime_sessions.feature_sessions.other).toMatchObject({
       planner_session_id: 'planner-b',
@@ -389,6 +616,9 @@ describe('MergeService', () => {
       if (args[0] === 'rev-parse' && args[1] === 'HEAD') {
         return commandResult({ stdout: 'abc123\n' });
       }
+      if (args[0] === 'rev-list') {
+        return commandResult({ stdout: '1\n' });
+      }
       return commandResult();
     });
 
@@ -432,6 +662,9 @@ describe('MergeService', () => {
         if (args[0] === 'rev-parse' && args[1] === 'HEAD') {
           return commandResult({ stdout: 'abc123\n' });
         }
+        if (args[0] === 'rev-list') {
+          return commandResult({ stdout: '1\n' });
+        }
         return commandResult();
       });
 
@@ -465,4 +698,337 @@ describe('MergeService', () => {
       vi.useRealTimers();
     }
   });
+
+  it('GIVEN_merge_fails_with_conflicts_and_resolve_enabled_WHEN_feature_ready_to_merge_THEN_auto_resolves_and_commits', async () => {
+    const harness = makeHarness();
+    // git add -A, commit (nothing to commit), status check, checkout main, merge fails with conflicts,
+    // checkout --theirs file1, git add -A, git commit --no-edit, rev-parse HEAD
+    vi.mocked(runGit)
+      .mockResolvedValueOnce(commandResult()) // add -A
+      .mockResolvedValueOnce(commandResult({ stdout: 'nothing to commit' })) // commit
+      .mockResolvedValueOnce(commandResult({ stdout: '1\n' })) // rev-list ahead count
+      .mockResolvedValueOnce(commandResult()) // status
+      .mockResolvedValueOnce(commandResult()) // checkout main
+      .mockResolvedValueOnce(
+        commandResult({
+          // merge fails with conflict
+          code: 1,
+          stdout: 'CONFLICT (content): Merge conflict in src/foo.ts\nAuto-merging src/bar.ts\n',
+        }),
+      )
+      .mockResolvedValueOnce(commandResult()) // checkout --theirs src/foo.ts
+      .mockResolvedValueOnce(commandResult()) // git add -A
+      .mockResolvedValueOnce(commandResult()) // git commit --no-edit
+      .mockResolvedValueOnce(commandResult({ stdout: 'resolved123\n' })); // rev-parse HEAD
+
+    const result = await harness.service.featureReadyToMerge(
+      'feature_merge',
+      'merge',
+      'merge_commit',
+      'approved',
+      true,
+    );
+
+    expect(result.data.merge_sha).toBe('resolved123');
+    expect(result.data.status).toBe(STATUS.MERGED);
+  });
+
+  it('GIVEN_checkout_theirs_fails_WHEN_resolve_enabled_THEN_throws_unresolvable_conflict', async () => {
+    const harness = makeHarness();
+    vi.mocked(runGit)
+      .mockResolvedValueOnce(commandResult()) // add -A
+      .mockResolvedValueOnce(commandResult()) // commit
+      .mockResolvedValueOnce(commandResult({ stdout: '1\n' })) // rev-list ahead count
+      .mockResolvedValueOnce(commandResult()) // status
+      .mockResolvedValueOnce(commandResult()) // checkout main
+      .mockResolvedValueOnce(
+        commandResult({
+          // merge fails with conflict
+          code: 1,
+          stdout: 'CONFLICT (content): Merge conflict in src/foo.ts\n',
+        }),
+      )
+      .mockResolvedValueOnce(commandResult({ code: 1, stderr: 'cannot checkout' })) // checkout --theirs fails
+      .mockResolvedValueOnce(commandResult()); // merge --abort
+
+    await expect(
+      harness.service.featureReadyToMerge(
+        'feature_merge',
+        'merge',
+        'merge_commit',
+        'approved',
+        true,
+      ),
+    ).rejects.toMatchObject({
+      normalizedResponse: { error: { code: ERROR_CODES.UNRESOLVABLE_CONFLICT } },
+    });
+  });
+
+  it('GIVEN_git_add_fails_after_resolve_WHEN_resolve_enabled_THEN_throws_git_failure', async () => {
+    const harness = makeHarness();
+    vi.mocked(runGit)
+      .mockResolvedValueOnce(commandResult()) // add -A
+      .mockResolvedValueOnce(commandResult()) // commit
+      .mockResolvedValueOnce(commandResult({ stdout: '1\n' })) // rev-list ahead count
+      .mockResolvedValueOnce(commandResult()) // status
+      .mockResolvedValueOnce(commandResult()) // checkout main
+      .mockResolvedValueOnce(
+        commandResult({
+          // merge fails with conflict
+          code: 1,
+          stdout: 'CONFLICT (content): Merge conflict in src/foo.ts\n',
+        }),
+      )
+      .mockResolvedValueOnce(commandResult()) // checkout --theirs succeeds
+      .mockResolvedValueOnce(commandResult({ code: 1, stderr: 'add failed' })) // git add -A fails
+      .mockResolvedValueOnce(commandResult()); // merge --abort
+
+    await expect(
+      harness.service.featureReadyToMerge(
+        'feature_merge',
+        'merge',
+        'merge_commit',
+        'approved',
+        true,
+      ),
+    ).rejects.toMatchObject({
+      normalizedResponse: { error: { code: ERROR_CODES.GIT_FAILURE } },
+    });
+  });
+
+  it('GIVEN_merge_fails_with_no_parseable_conflicts_and_resolve_enabled_WHEN_merge_THEN_aborts_and_throws_git_failure', async () => {
+    const harness = makeHarness();
+    vi.mocked(runGit)
+      .mockResolvedValueOnce(commandResult()) // add -A
+      .mockResolvedValueOnce(commandResult()) // commit
+      .mockResolvedValueOnce(commandResult({ stdout: '1\n' })) // rev-list ahead count
+      .mockResolvedValueOnce(commandResult()) // status
+      .mockResolvedValueOnce(commandResult()) // checkout main
+      .mockResolvedValueOnce(commandResult({ code: 1, stderr: 'merge failed for unknown reason' })) // merge fails, no CONFLICT lines
+      .mockResolvedValueOnce(commandResult()); // merge --abort
+
+    await expect(
+      harness.service.featureReadyToMerge(
+        'feature_merge',
+        'merge',
+        'merge_commit',
+        'approved',
+        true,
+      ),
+    ).rejects.toMatchObject({
+      normalizedResponse: { error: { code: ERROR_CODES.GIT_FAILURE } },
+    });
+    expect(vi.mocked(runGit)).toHaveBeenCalledWith('/repo', ['merge', '--abort']);
+  });
+
+  it('GIVEN_merge_target_is_base_branch_WHEN_feature_merges_THEN_merges_directly_to_main', async () => {
+    const harness = makeHarness({
+      policyOverrides: {
+        merge_policy: {
+          allowed_strategies: ['merge_commit'],
+          require_user_approval: false,
+          merge_target: 'base_branch',
+        },
+      },
+    });
+    vi.mocked(runGit)
+      .mockResolvedValueOnce(commandResult()) // add -A
+      .mockResolvedValueOnce(commandResult()) // commit
+      .mockResolvedValueOnce(commandResult({ stdout: '1\n' })) // rev-list ahead count
+      .mockResolvedValueOnce(commandResult()) // status check
+      .mockResolvedValueOnce(commandResult()) // checkout main
+      .mockResolvedValueOnce(commandResult()) // merge
+      .mockResolvedValueOnce(commandResult({ stdout: 'abc123\n' })); // rev-parse
+
+    const result = await harness.service.featureReadyToMerge(
+      'feature_merge',
+      'merge commit',
+      'merge_commit',
+      null,
+    );
+
+    expect(result.data.merge_sha).toBe('abc123');
+    expect(result.data.merge_target).toBe('main');
+    const checkoutCall = vi.mocked(runGit).mock.calls[4];
+    expect(checkoutCall[1]).toEqual(['checkout', 'main']);
+  });
+
+  it('GIVEN_merge_target_is_feature_branch_WHEN_feature_merges_THEN_creates_aop_branch_and_merges_there', async () => {
+    const harness = makeHarness({
+      policyOverrides: {
+        merge_policy: {
+          allowed_strategies: ['merge_commit'],
+          require_user_approval: false,
+          merge_target: 'feature_branch',
+        },
+      },
+    });
+    vi.mocked(runGit)
+      .mockResolvedValueOnce(commandResult()) // add -A
+      .mockResolvedValueOnce(commandResult()) // commit
+      .mockResolvedValueOnce(commandResult({ stdout: '1\n' })) // rev-list ahead count
+      .mockResolvedValueOnce(commandResult()) // status check
+      .mockResolvedValueOnce(commandResult({ code: 1 })) // branch -D aop/feature_merge (stale — not found, OK)
+      .mockResolvedValueOnce(commandResult()) // branch aop/feature_merge main
+      .mockResolvedValueOnce(commandResult()) // checkout aop/feature_merge
+      .mockResolvedValueOnce(commandResult()) // merge
+      .mockResolvedValueOnce(commandResult({ stdout: 'def456\n' })); // rev-parse
+
+    const result = await harness.service.featureReadyToMerge(
+      'feature_merge',
+      'merge commit',
+      'merge_commit',
+      null,
+    );
+
+    expect(result.data.merge_sha).toBe('def456');
+    expect(result.data.merge_target).toBe('aop/feature_merge');
+    const branchCreateCall = vi.mocked(runGit).mock.calls[5];
+    expect(branchCreateCall[1]).toEqual(['branch', 'aop/feature_merge', 'main']);
+    const checkoutCall = vi.mocked(runGit).mock.calls[6];
+    expect(checkoutCall[1]).toEqual(['checkout', 'aop/feature_merge']);
+  });
+
+  it('GIVEN_merge_target_is_feature_branch_WHEN_merge_completes_THEN_main_is_untouched', async () => {
+    const harness = makeHarness({
+      policyOverrides: {
+        merge_policy: {
+          allowed_strategies: ['merge_commit'],
+          require_user_approval: false,
+          merge_target: 'feature_branch',
+        },
+      },
+    });
+    vi.mocked(runGit)
+      .mockResolvedValueOnce(commandResult()) // add -A
+      .mockResolvedValueOnce(commandResult()) // commit
+      .mockResolvedValueOnce(commandResult({ stdout: '1\n' })) // rev-list
+      .mockResolvedValueOnce(commandResult()) // status
+      .mockResolvedValueOnce(commandResult({ code: 1 })) // branch -D (stale)
+      .mockResolvedValueOnce(commandResult()) // branch create
+      .mockResolvedValueOnce(commandResult()) // checkout aop/
+      .mockResolvedValueOnce(commandResult()) // merge
+      .mockResolvedValueOnce(commandResult({ stdout: 'sha1\n' })); // rev-parse
+
+    await harness.service.featureReadyToMerge(
+      'feature_merge',
+      'merge commit',
+      'merge_commit',
+      null,
+    );
+
+    const allCalls = vi.mocked(runGit).mock.calls;
+    const checkoutMainCalls = allCalls.filter(
+      (call) => Array.isArray(call[1]) && call[1][0] === 'checkout' && call[1][1] === 'main',
+    );
+    expect(checkoutMainCalls).toHaveLength(0);
+  });
+
+  it('GIVEN_merge_target_is_feature_branch_WHEN_cleanup_runs_THEN_aop_branch_is_preserved', async () => {
+    const harness = makeHarness({
+      policyOverrides: {
+        merge_policy: {
+          allowed_strategies: ['merge_commit'],
+          require_user_approval: false,
+          merge_target: 'feature_branch',
+        },
+        cleanup: {
+          auto_after_merge: true,
+          grace_period_seconds: 0,
+        },
+      },
+    });
+    vi.mocked(runGit)
+      .mockResolvedValueOnce(commandResult()) // add -A
+      .mockResolvedValueOnce(commandResult()) // commit
+      .mockResolvedValueOnce(commandResult({ stdout: '1\n' })) // rev-list
+      .mockResolvedValueOnce(commandResult()) // status
+      .mockResolvedValueOnce(commandResult({ code: 1 })) // branch -D stale (pre-merge, OK to fail)
+      .mockResolvedValueOnce(commandResult()) // branch create
+      .mockResolvedValueOnce(commandResult()) // checkout aop/
+      .mockResolvedValueOnce(commandResult()) // merge
+      .mockResolvedValueOnce(commandResult({ stdout: 'sha1\n' })) // rev-parse
+      .mockResolvedValueOnce(commandResult()) // worktree remove (cleanup)
+      .mockResolvedValueOnce(commandResult()); // branch -D feature_merge (cleanup)
+
+    await harness.service.featureReadyToMerge(
+      'feature_merge',
+      'merge commit',
+      'merge_commit',
+      null,
+    );
+
+    // Call at index 9 (0-based) is the cleanup worktree remove; index 10 is the cleanup branch -D.
+    // The stale-delete at index 4 is expected (pre-merge housekeeping, not cleanup).
+    // Verify cleanup only deletes the feature branch, not the aop/ merge-target branch.
+    const allCalls = vi.mocked(runGit).mock.calls;
+    // cleanup branch delete is the last branch -D call (index 10)
+    const cleanupBranchDeleteCall = allCalls[10];
+    expect(cleanupBranchDeleteCall[1]).toEqual(['branch', '-D', 'feature_merge']);
+    // Confirm total branch -D call count is 2: one stale-delete pre-merge + one cleanup
+    const branchDeleteCalls = allCalls.filter(
+      (call) => Array.isArray(call[1]) && call[1][0] === 'branch' && call[1][1] === '-D',
+    );
+    expect(branchDeleteCalls).toHaveLength(2);
+    const deletedBranches = branchDeleteCalls.map((call) => call[1][2]);
+    // The pre-merge stale-delete targets aop/feature_merge; cleanup targets feature_merge
+    expect(deletedBranches[0]).toBe('aop/feature_merge');
+    expect(deletedBranches[1]).toBe('feature_merge');
+  });
+
+  it('GIVEN_merge_target_omitted_WHEN_feature_merges_THEN_defaults_to_base_branch', async () => {
+    const harness = makeHarness(); // No merge_target in policy
+    vi.mocked(runGit)
+      .mockResolvedValueOnce(commandResult()) // add -A
+      .mockResolvedValueOnce(commandResult()) // commit
+      .mockResolvedValueOnce(commandResult({ stdout: '1\n' })) // rev-list
+      .mockResolvedValueOnce(commandResult()) // status
+      .mockResolvedValueOnce(commandResult()) // checkout main
+      .mockResolvedValueOnce(commandResult()) // merge
+      .mockResolvedValueOnce(commandResult({ stdout: 'abc\n' })); // rev-parse
+
+    const result = await harness.service.featureReadyToMerge(
+      'feature_merge',
+      'merge commit',
+      'merge_commit',
+      null,
+    );
+
+    expect(result.data.merge_target).toBe('main');
+    const checkoutCall = vi.mocked(runGit).mock.calls[4];
+    expect(checkoutCall[1]).toEqual(['checkout', 'main']);
+  });
+
+  it('GIVEN_merge_target_is_feature_branch_with_squash_WHEN_feature_merges_THEN_squash_lands_on_aop_branch', async () => {
+    const harness = makeHarness({
+      policyOverrides: {
+        merge_policy: {
+          allowed_strategies: ['squash'],
+          require_user_approval: false,
+          merge_target: 'feature_branch',
+        },
+      },
+    });
+    vi.mocked(runGit)
+      .mockResolvedValueOnce(commandResult()) // add -A
+      .mockResolvedValueOnce(commandResult()) // commit
+      .mockResolvedValueOnce(commandResult({ stdout: '1\n' })) // rev-list
+      .mockResolvedValueOnce(commandResult()) // status
+      .mockResolvedValueOnce(commandResult({ code: 1 })) // branch -D stale
+      .mockResolvedValueOnce(commandResult()) // branch create
+      .mockResolvedValueOnce(commandResult()) // checkout aop/
+      .mockResolvedValueOnce(commandResult()) // merge --squash
+      .mockResolvedValueOnce(commandResult()) // commit (squash)
+      .mockResolvedValueOnce(commandResult({ stdout: 'squash-sha\n' })); // rev-parse
+
+    const result = await harness.service.featureReadyToMerge(
+      'feature_merge',
+      'merge commit',
+      'squash',
+      null,
+    );
+
+    expect(result.data.merge_sha).toBe('squash-sha');
+    expect(result.data.merge_target).toBe('aop/feature_merge');
+  });
 });