Method finish

src/agent/git-sandbox.ts:339–417

* Leave the sandbox. * ok=true → squash all sandbox work into ONE commit on the origin branch. * ok=false → abandon the sandbox branch; restore the user's original state. * Either way we return to the origin branch and pop the WIP stash.

(ok: boolean, commitMessage: string, signal?: AbortSignal)

   * Either way we return to the origin branch and pop the WIP stash.
   */
  async finish(ok: boolean, commitMessage: string, signal?: AbortSignal): Promise<FinishResult> {
    if (!this.state?.active) return { merged: false, reason: 'empty' };
    const { branch, originBranch, baseCommit, stashed, stashMessage } = this.state;
    // Distinguish a genuine "nothing to merge" (empty) from a real merge failure
    // (conflict/error). Default to 'empty' for the !ok abandon path; the ok path
    // overrides this when the squash actually fails.
    let merged = false;
    let failReason: 'empty' | 'conflict' | 'error' = 'empty';
    let failError: string | undefined;
    try {
      if (ok) {
        // Stage everything still uncommitted, then commit so squash captures it.
        await git(['add', '-A'], { cwd: this.cwd, signal });
        await git(['commit', '--no-verify', '--allow-empty', '-m', 'qodex sandbox final'], { cwd: this.cwd, signal });
        // Back to origin, squash-merge the diff from base→branch as a single commit.
        await git(['checkout', originBranch], { cwd: this.cwd, signal });
        const sq = await git(['merge', '--squash', branch], { cwd: this.cwd, signal });
        if ((sq.exitCode === 0)) {
          const c = await git(['commit', '--no-verify', '-m', commitMessage], { cwd: this.cwd, signal });
          merged = (c.exitCode === 0);
          if (!merged) {
            // Squash staged nothing → empty commit refused. That's a genuine
            // "no committed changes" case, not a failure.
            const out = `${c.stdout ?? ''}\n${c.stderr ?? ''}`;
            failReason = /nothing to commit|no changes added/i.test(out) ? 'empty' : 'error';
            if (failReason === 'error') failError = (c.stderr || c.stdout || '').trim() || undefined;
          }
        } else {
          // Merge itself failed (e.g. conflict) — surface it as a real failure.
          merged = false;
          const out = `${sq.stdout ?? ''}\n${sq.stderr ?? ''}`;
          failReason = /conflict|CONFLICT/.test(out) ? 'conflict' : 'error';
          failError = (sq.stderr || sq.stdout || '').trim() || undefined;
        }
        if (!merged) {
          // Squash had nothing or failed; ensure we at least left the branch.
          await git(['merge', '--abort'], { cwd: this.cwd, signal }).catch(() => {});
        }
      } else {
        // Abandon: just return to origin; the sandbox branch is left for forensics.
        await git(['checkout', '--force', originBranch], { cwd: this.cwd, signal });
        // Only hard-reset origin once we've confirmed we're actually on it — never
        // blow away whatever branch we happen to be on if the checkout failed.
        const cur = await this.currentBranch(signal);
        if (cur === originBranch) {
          await git(['reset', '--hard', baseCommit], { cwd: this.cwd, signal });
        } else {
          logger.warn('GitSandbox.finish: not on origin after checkout — skipping reset --hard', { expected: originBranch, actual: cur });
        }
      }
      // Delete the throwaway branch (best-effort).
      await git(['branch', '-D', branch], { cwd: this.cwd, signal }).catch(() => {});
      // Restore the user's pre-sandbox WIP via the SPECIFIC stash (by message),
      // never a positional pop that could cross-pop another session's stash. A
      // conflict is surfaced (logged), not silently swallowed.
      if (stashed && stashMessage) {
        await this.restoreStashByMessage(stashMessage, signal);
      }