xtrm-cli 0.5.0 → 0.5.27

package/src/core/xtrm-finish.ts

@@ -1,267 +0,0 @@
-import { spawnSync } from 'node:child_process';
-import { existsSync } from 'node:fs';
-import {
-  readSessionState,
-  updateSessionPhase,
-  type SessionState,
-} from './session-state.js';
-
-export interface FinishOptions {
-  cwd?: string;
-  pollIntervalMs?: number;
-  timeoutMs?: number;
-}
-
-export interface FinishResult {
-  ok: boolean;
-  message: string;
-}
-
-interface CmdResult {
-  code: number;
-  stdout: string;
-  stderr: string;
-}
-
-const DEFAULT_POLL_INTERVAL_MS = 5000;
-const DEFAULT_TIMEOUT_MS = 10 * 60 * 1000;
-
-function run(cmd: string, args: string[], cwd: string): CmdResult {
-  const r = spawnSync(cmd, args, {
-    cwd,
-    encoding: 'utf8',
-    stdio: ['pipe', 'pipe', 'pipe'],
-  });
-  return {
-    code: r.status ?? 1,
-    stdout: (r.stdout ?? '').trim(),
-    stderr: (r.stderr ?? '').trim(),
-  };
-}
-
-function getControlRepoRoot(cwd: string): string {
-  const commonDir = run('git', ['rev-parse', '--path-format=absolute', '--git-common-dir'], cwd);
-  if (commonDir.code === 0 && commonDir.stdout) {
-    return commonDir.stdout.replace(/\/.git$/, '');
-  }
-  return cwd;
-}
-
-function resolveExecutionCwd(controlCwd: string, state: SessionState): string {
-  if (state.worktreePath && existsSync(state.worktreePath)) {
-    return state.worktreePath;
-  }
-  return controlCwd;
-}
-
-function parsePrCreate(stdout: string): { prNumber: number | null; prUrl: string | null } {
-  const urlMatch = stdout.match(/https?:\/\/\S+\/pull\/(\d+)/);
-  if (urlMatch) {
-    return { prNumber: Number(urlMatch[1]), prUrl: urlMatch[0] };
-  }
-
-  const numberMatch = stdout.match(/#(\d+)/);
-  if (numberMatch) {
-    return { prNumber: Number(numberMatch[1]), prUrl: null };
-  }
-
-  return { prNumber: null, prUrl: null };
-}
-
-function getConflictFiles(cwd: string): string[] {
-  const out = run('git', ['diff', '--name-only', '--diff-filter=U'], cwd);
-  if (out.code !== 0 || !out.stdout) return [];
-  return out.stdout.split('\n').map((s) => s.trim()).filter(Boolean);
-}
-
-async function delay(ms: number): Promise<void> {
-  if (ms <= 0) return;
-  await new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-function ensureCleanPhaseTransition(cwd: string, phase: SessionState['phase'], patch: Partial<SessionState> = {}) {
-  try {
-    updateSessionPhase(phase, cwd, patch);
-  } catch {
-    // non-fatal for re-entrant paths
-  }
-}
-
-function handleRebaseAndPush(cwd: string): { ok: boolean; conflicts?: string[]; error?: string } {
-  const fetch = run('git', ['fetch', 'origin'], cwd);
-  if (fetch.code !== 0) return { ok: false, error: fetch.stderr || fetch.stdout };
-
-  const rebase = run('git', ['rebase', 'origin/main'], cwd);
-  if (rebase.code !== 0) {
-    const conflicts = getConflictFiles(cwd);
-    return { ok: false, conflicts, error: rebase.stderr || rebase.stdout };
-  }
-
-  const push = run('git', ['push', '--force-with-lease'], cwd);
-  if (push.code !== 0) {
-    return { ok: false, error: push.stderr || push.stdout };
-  }
-
-  return { ok: true };
-}
-
-function cleanupPhase(controlCwd: string, state: SessionState): FinishResult {
-  if (existsSync(state.worktreePath)) {
-    const rm = run('git', ['worktree', 'remove', state.worktreePath, '--force'], controlCwd);
-    if (rm.code !== 0) {
-      return { ok: false, message: rm.stderr || rm.stdout || `Failed to remove worktree ${state.worktreePath}` };
-    }
-  }
-
-  run('git', ['fetch', '--prune'], controlCwd);
-  ensureCleanPhaseTransition(controlCwd, 'cleanup-done');
-
-  const prLabel = state.prNumber != null ? `#${state.prNumber}` : '(unknown PR)';
-  return { ok: true, message: `Done. PR ${prLabel} merged. Worktree removed.` };
-}
-
-async function pollUntilMerged(controlCwd: string, executionCwd: string, state: SessionState, opts: Required<FinishOptions>): Promise<FinishResult> {
-  if (state.prNumber == null) {
-    return { ok: false, message: 'Session state missing prNumber. Re-run phase 1 before polling.' };
-  }
-
-  const started = Date.now();
-  while ((Date.now() - started) < opts.timeoutMs) {
-    const view = run('gh', ['pr', 'view', String(state.prNumber), '--json', 'state,mergeStateStatus,mergeable'], executionCwd);
-
-    if (view.code !== 0) {
-      return { ok: false, message: view.stderr || view.stdout || `Failed to inspect PR #${state.prNumber}` };
-    }
-
-    let payload: any = null;
-    try {
-      payload = JSON.parse(view.stdout);
-    } catch {
-      return { ok: false, message: `Unable to parse gh pr view output for #${state.prNumber}` };
-    }
-
-    ensureCleanPhaseTransition(controlCwd, 'waiting-merge');
-
-    if (payload.state === 'MERGED') {
-      ensureCleanPhaseTransition(controlCwd, 'merged');
-      const latest = readSessionState(controlCwd) ?? state;
-      return cleanupPhase(controlCwd, latest);
-    }
-
-    if (payload.mergeStateStatus === 'BEHIND') {
-      run('git', ['fetch', 'origin'], executionCwd);
-      run('git', ['push'], executionCwd);
-      await delay(opts.pollIntervalMs);
-      continue;
-    }
-
-    if (payload.mergeable === 'CONFLICTING') {
-      const rebased = handleRebaseAndPush(executionCwd);
-      if (!rebased.ok) {
-        const conflictFiles = rebased.conflicts ?? getConflictFiles(executionCwd);
-        ensureCleanPhaseTransition(controlCwd, 'conflicting', { conflictFiles });
-        return {
-          ok: false,
-          message: `Conflicts in: ${conflictFiles.join(', ') || 'unknown files'}. Resolve, push, then re-run xtrm finish.`,
-        };
-      }
-
-      ensureCleanPhaseTransition(controlCwd, 'waiting-merge', { conflictFiles: [] });
-      await delay(opts.pollIntervalMs);
-      continue;
-    }
-
-    await delay(opts.pollIntervalMs);
-  }
-
-  ensureCleanPhaseTransition(controlCwd, 'pending-cleanup');
-  return {
-    ok: false,
-    message: `PR #${state.prNumber} not yet merged. Run xtrm finish when ready.`,
-  };
-}
-
-function isWorkingTreeDirty(cwd: string): boolean {
-  const st = run('git', ['status', '--porcelain'], cwd);
-  return st.code === 0 && st.stdout.length > 0;
-}
-
-function runPhase1(controlCwd: string, executionCwd: string, state: SessionState): FinishResult {
-  if (isWorkingTreeDirty(executionCwd)) {
-    const add = run('git', ['add', '-A'], executionCwd);
-    if (add.code !== 0) return { ok: false, message: add.stderr || add.stdout };
-
-    const msg = `feat(${state.issueId}): ${state.branch}`;
-    const commit = run('git', ['commit', '-m', msg], executionCwd);
-    if (commit.code !== 0) {
-      return { ok: false, message: commit.stderr || commit.stdout || 'git commit failed' };
-    }
-  }
-
-  const push = run('git', ['push', '-u', 'origin', state.branch], executionCwd);
-  if (push.code !== 0) return { ok: false, message: push.stderr || push.stdout || 'git push failed' };
-
-  const create = run('gh', ['pr', 'create', '--fill'], executionCwd);
-  if (create.code !== 0) return { ok: false, message: create.stderr || create.stdout || 'gh pr create failed' };
-  const parsed = parsePrCreate(create.stdout);
-
-  const merge = run('gh', ['pr', 'merge', '--squash', '--auto'], executionCwd);
-  if (merge.code !== 0) return { ok: false, message: merge.stderr || merge.stdout || 'gh pr merge failed' };
-
-  ensureCleanPhaseTransition(controlCwd, 'phase1-done', {
-    prNumber: parsed.prNumber,
-    prUrl: parsed.prUrl,
-  });
-  ensureCleanPhaseTransition(controlCwd, 'waiting-merge', {
-    prNumber: parsed.prNumber,
-    prUrl: parsed.prUrl,
-  });
-
-  return { ok: true, message: 'phase1 complete' };
-}
-
-export async function runXtrmFinish(options: FinishOptions = {}): Promise<FinishResult> {
-  const cwd = options.cwd ?? process.cwd();
-  const controlCwd = getControlRepoRoot(cwd);
-
-  const state = readSessionState(controlCwd);
-  if (!state) {
-    return { ok: false, message: 'No .xtrm-session-state.json found. Claim an issue first (bd update <id> --claim).' };
-  }
-
-  const executionCwd = resolveExecutionCwd(controlCwd, state);
-
-  const opts: Required<FinishOptions> = {
-    cwd: controlCwd,
-    pollIntervalMs: options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS,
-    timeoutMs: options.timeoutMs ?? DEFAULT_TIMEOUT_MS,
-  };
-
-  if (state.phase === 'cleanup-done') {
-    return { ok: true, message: 'Session is already cleanup-done.' };
-  }
-
-  if (state.phase === 'conflicting') {
-    const resolved = handleRebaseAndPush(executionCwd);
-    if (!resolved.ok) {
-      const files = resolved.conflicts ?? getConflictFiles(executionCwd);
-      ensureCleanPhaseTransition(controlCwd, 'conflicting', { conflictFiles: files });
-      return { ok: false, message: `Conflicts in: ${files.join(', ') || 'unknown files'}. Resolve, push, then re-run xtrm finish.` };
-    }
-    ensureCleanPhaseTransition(controlCwd, 'waiting-merge', { conflictFiles: [] });
-    const refreshed = readSessionState(controlCwd) ?? state;
-    return pollUntilMerged(controlCwd, executionCwd, refreshed, opts);
-  }
-
-  if (state.phase === 'waiting-merge' || state.phase === 'pending-cleanup' || state.phase === 'merged') {
-    const refreshed = readSessionState(controlCwd) ?? state;
-    if (refreshed.phase === 'merged') return cleanupPhase(controlCwd, refreshed);
-    return pollUntilMerged(controlCwd, executionCwd, refreshed, opts);
-  }
-
-  const phase1 = runPhase1(controlCwd, executionCwd, state);
-  if (!phase1.ok) return phase1;
-
-  const refreshed = readSessionState(controlCwd) ?? state;
-  return pollUntilMerged(controlCwd, executionCwd, refreshed, opts);
-}

package/src/tests/session-flow-parity.test.ts

@@ -1,118 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { readFileSync, existsSync, mkdtempSync, mkdirSync, writeFileSync, chmodSync, rmSync } from 'node:fs';
-import path from 'node:path';
-import os from 'node:os';
-import { spawnSync } from 'node:child_process';
-
-const ROOT = path.resolve(__dirname, '..', '..', '..');
-const HOOKS_DIR = path.join(ROOT, 'hooks');
-
-function runHook(hookFile: string, input: Record<string, unknown>, env: Record<string, string> = {}) {
-  return spawnSync('node', [path.join(HOOKS_DIR, hookFile)], {
-    input: JSON.stringify(input),
-    encoding: 'utf8',
-    env: { ...process.env, ...env },
-  });
-}
-
-function withFakeBdDir(scriptBody: string) {
-  const tempDir = mkdtempSync(path.join(os.tmpdir(), 'xtrm-fakebd-'));
-  const fakeBdPath = path.join(tempDir, 'bd');
-  writeFileSync(fakeBdPath, scriptBody, { encoding: 'utf8' });
-  chmodSync(fakeBdPath, 0o755);
-  return { tempDir, fakeBdPath };
-}
-
-describe('session-flow policy parity', () => {
-  it('declares runtime:both with Claude hooks and Pi extension', () => {
-    const policy = JSON.parse(readFileSync(path.join(ROOT, 'policies', 'session-flow.json'), 'utf8'));
-    expect(policy.runtime).toBe('both');
-    expect(policy.order).toBeLessThan(20); // must run before beads stop memory gate
-    expect(policy.claude?.hooks?.length).toBeGreaterThan(0);
-    expect(policy.pi?.extension).toBe('config/pi/extensions/session-flow.ts');
-    expect(existsSync(path.join(ROOT, policy.pi.extension))).toBe(true);
-  });
-
-  it('compiled hooks run stop gate before memory gate', () => {
-    const hooks = JSON.parse(readFileSync(path.join(ROOT, 'hooks', 'hooks.json'), 'utf8'));
-    const stopGroups = hooks?.hooks?.Stop ?? [];
-    const commands: string[] = stopGroups.flatMap((g: any) => (g.hooks ?? []).map((h: any) => String(h.command)));
-    const stopIdx = commands.findIndex((c) => c.includes('beads-stop-gate.mjs'));
-    const memIdx = commands.findIndex((c) => c.includes('beads-memory-gate.mjs'));
-    expect(stopIdx).toBeGreaterThanOrEqual(0);
-    expect(memIdx).toBeGreaterThanOrEqual(0);
-    expect(stopIdx).toBeLessThan(memIdx);
-  });
-
-  it('Claude stop hook enforces phase blocking contract', () => {
-    const projectDir = mkdtempSync(path.join(os.tmpdir(), 'xtrm-session-flow-stop-'));
-    mkdirSync(path.join(projectDir, '.beads'));
-
-    const fake = withFakeBdDir(`#!/usr/bin/env bash
-set -euo pipefail
-if [[ "$1" == "kv" && "$2" == "get" ]]; then exit 1; fi
-if [[ "$1" == "list" ]]; then
-  cat <<'EOF'
-
---------------------------------------------------------------------------------
-Total: 0 issues (0 open, 0 in progress)
-EOF
-  exit 0
-fi
-exit 1
-`);
-
-    try {
-      const cases = [
-        { phase: 'waiting-merge', blocked: true },
-        { phase: 'pending-cleanup', blocked: true },
-        { phase: 'conflicting', blocked: true },
-        { phase: 'cleanup-done', blocked: false },
-      ];
-
-      for (const c of cases) {
-        writeFileSync(path.join(projectDir, '.xtrm-session-state.json'), JSON.stringify({
-          issueId: 'jaggers-agent-tools-1xa2',
-          branch: 'feature/jaggers-agent-tools-1xa2',
-          worktreePath: '/tmp/worktrees/jaggers-agent-tools-1xa2',
-          prNumber: 101,
-          prUrl: 'https://example.invalid/pr/101',
-          phase: c.phase,
-          conflictFiles: c.phase === 'conflicting' ? ['src/a.ts'] : [],
-          startedAt: new Date().toISOString(),
-          lastChecked: new Date().toISOString(),
-        }), 'utf8');
-
-        const r = runHook(
-          'beads-stop-gate.mjs',
-          { hook_event_name: 'Stop', session_id: 'parity-session', cwd: projectDir },
-          { PATH: `${fake.tempDir}:${process.env.PATH ?? ''}` },
-        );
-
-        if (c.blocked) {
-          expect(r.status, `expected block for ${c.phase}`).toBe(2);
-        } else {
-          expect(r.status, `expected allow for ${c.phase}`).toBe(0);
-        }
-      }
-    } finally {
-      rmSync(fake.tempDir, { recursive: true, force: true });
-      rmSync(projectDir, { recursive: true, force: true });
-    }
-  });
-
-  it('Pi extension encodes same phase guards and claim detection semantics', () => {
-    const src = readFileSync(path.join(ROOT, 'config', 'pi', 'extensions', 'session-flow.ts'), 'utf8');
-
-    // claim detection path
-    expect(src).toContain('bd\\s+update');
-    expect(src).toContain('--claim');
-
-    // phase parity with Claude stop-gate
-    expect(src).toContain('waiting-merge');
-    expect(src).toContain('pending-cleanup');
-    expect(src).toContain('conflicting');
-    expect(src).toContain('phase1-done');
-    expect(src).toContain('xtrm finish');
-  });
-});

package/src/tests/session-state.test.ts

@@ -1,124 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { mkdtempSync, mkdirSync, readFileSync, rmSync } from 'node:fs';
-import path from 'node:path';
-import os from 'node:os';
-
-import {
-  findSessionStateFile,
-  readSessionState,
-  writeSessionState,
-  updateSessionPhase,
-} from '../core/session-state.js';
-
-describe('session-state.ts', () => {
-  it('returns null when no state file exists', () => {
-    const dir = mkdtempSync(path.join(os.tmpdir(), 'xtrm-session-state-none-'));
-    try {
-      expect(findSessionStateFile(dir)).toBeNull();
-      expect(readSessionState(dir)).toBeNull();
-    } finally {
-      rmSync(dir, { recursive: true, force: true });
-    }
-  });
-
-  it('writes and reads state roundtrip', () => {
-    const dir = mkdtempSync(path.join(os.tmpdir(), 'xtrm-session-state-roundtrip-'));
-    try {
-      writeSessionState({
-        issueId: 'jaggers-agent-tools-1xa2',
-        branch: 'feature/jaggers-agent-tools-1xa2',
-        worktreePath: '/tmp/worktrees/jaggers-agent-tools-1xa2',
-        prNumber: null,
-        prUrl: null,
-        phase: 'claimed',
-        conflictFiles: [],
-        startedAt: new Date().toISOString(),
-        lastChecked: new Date().toISOString(),
-      }, dir);
-
-      const state = readSessionState(dir);
-      expect(state).not.toBeNull();
-      expect(state?.issueId).toBe('jaggers-agent-tools-1xa2');
-      expect(state?.phase).toBe('claimed');
-      expect(Array.isArray(state?.conflictFiles)).toBe(true);
-    } finally {
-      rmSync(dir, { recursive: true, force: true });
-    }
-  });
-
-  it('findSessionStateFile walks up directory tree', () => {
-    const root = mkdtempSync(path.join(os.tmpdir(), 'xtrm-session-state-walk-'));
-    const nested = path.join(root, 'a', 'b', 'c');
-    mkdirSync(nested, { recursive: true });
-
-    try {
-      writeSessionState({
-        issueId: 'walk-1',
-        branch: 'feature/walk-1',
-        worktreePath: '/tmp/worktrees/walk-1',
-        prNumber: null,
-        prUrl: null,
-        phase: 'claimed',
-        conflictFiles: [],
-        startedAt: new Date().toISOString(),
-        lastChecked: new Date().toISOString(),
-      }, root);
-
-      const found = findSessionStateFile(nested);
-      expect(found).toBe(path.join(root, '.xtrm-session-state.json'));
-    } finally {
-      rmSync(root, { recursive: true, force: true });
-    }
-  });
-
-  it('enforces phase transition validation', () => {
-    const dir = mkdtempSync(path.join(os.tmpdir(), 'xtrm-session-state-phase-'));
-    try {
-      writeSessionState({
-        issueId: 'phase-1',
-        branch: 'feature/phase-1',
-        worktreePath: '/tmp/worktrees/phase-1',
-        prNumber: null,
-        prUrl: null,
-        phase: 'claimed',
-        conflictFiles: [],
-        startedAt: new Date().toISOString(),
-        lastChecked: new Date().toISOString(),
-      }, dir);
-
-      const waiting = updateSessionPhase('waiting-merge', dir, { prNumber: 12 });
-      expect(waiting.phase).toBe('waiting-merge');
-
-      const done = updateSessionPhase('cleanup-done', dir);
-      expect(done.phase).toBe('cleanup-done');
-
-      expect(() => updateSessionPhase('claimed', dir)).toThrow(/Invalid phase transition/);
-    } finally {
-      rmSync(dir, { recursive: true, force: true });
-    }
-  });
-
-  it('updates persisted file on phase changes', () => {
-    const dir = mkdtempSync(path.join(os.tmpdir(), 'xtrm-session-state-persist-'));
-    try {
-      writeSessionState({
-        issueId: 'persist-1',
-        branch: 'feature/persist-1',
-        worktreePath: '/tmp/worktrees/persist-1',
-        prNumber: null,
-        prUrl: null,
-        phase: 'claimed',
-        conflictFiles: [],
-        startedAt: new Date().toISOString(),
-        lastChecked: new Date().toISOString(),
-      }, dir);
-
-      updateSessionPhase('conflicting', dir, { conflictFiles: ['src/core.ts'] });
-      const raw = JSON.parse(readFileSync(path.join(dir, '.xtrm-session-state.json'), 'utf8'));
-      expect(raw.phase).toBe('conflicting');
-      expect(raw.conflictFiles).toContain('src/core.ts');
-    } finally {
-      rmSync(dir, { recursive: true, force: true });
-    }
-  });
-});

package/src/tests/xtrm-finish.test.ts

@@ -1,148 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { mkdtempSync, mkdirSync, rmSync, writeFileSync, readFileSync, chmodSync } from 'node:fs';
-import path from 'node:path';
-import os from 'node:os';
-import { spawnSync } from 'node:child_process';
-
-import { runXtrmFinish } from '../core/xtrm-finish.js';
-
-function initRepo(dir: string) {
-  spawnSync('git', ['init'], { cwd: dir, stdio: 'pipe' });
-  spawnSync('git', ['config', 'user.email', 'test@example.com'], { cwd: dir, stdio: 'pipe' });
-  spawnSync('git', ['config', 'user.name', 'Test User'], { cwd: dir, stdio: 'pipe' });
-  writeFileSync(path.join(dir, 'README.md'), '# test\n', 'utf8');
-  spawnSync('git', ['add', 'README.md'], { cwd: dir, stdio: 'pipe' });
-  spawnSync('git', ['commit', '-m', 'init'], { cwd: dir, stdio: 'pipe' });
-}
-
-describe('runXtrmFinish', () => {
-  it('fails when session state file is missing', async () => {
-    const dir = mkdtempSync(path.join(os.tmpdir(), 'xtrm-finish-none-'));
-    try {
-      const result = await runXtrmFinish({ cwd: dir, pollIntervalMs: 1, timeoutMs: 5 });
-      expect(result.ok).toBe(false);
-      expect(result.message).toContain('.xtrm-session-state.json');
-    } finally {
-      rmSync(dir, { recursive: true, force: true });
-    }
-  });
-
-  it('re-entrant waiting-merge path reaches cleanup-done on merged PR', async () => {
-    const dir = mkdtempSync(path.join(os.tmpdir(), 'xtrm-finish-merge-'));
-    const fakeDir = path.join(dir, 'fakebin');
-    mkdirSync(fakeDir, { recursive: true });
-    initRepo(dir);
-
-    writeFileSync(path.join(dir, '.xtrm-session-state.json'), JSON.stringify({
-      issueId: 'jaggers-agent-tools-1xa2',
-      branch: 'feature/jaggers-agent-tools-1xa2',
-      worktreePath: '/tmp/nonexistent-worktree-path',
-      prNumber: 42,
-      prUrl: 'https://example.invalid/pr/42',
-      phase: 'waiting-merge',
-      conflictFiles: [],
-      startedAt: new Date().toISOString(),
-      lastChecked: new Date().toISOString(),
-    }), 'utf8');
-
-    const ghPath = path.join(fakeDir, 'gh');
-    writeFileSync(ghPath, `#!/usr/bin/env bash\nset -euo pipefail\nif [[ "$1" == "pr" && "$2" == "view" ]]; then\n  echo '{"state":"MERGED","mergeStateStatus":"CLEAN","mergeable":"MERGEABLE"}'\n  exit 0\nfi\nexit 1\n`);
-    chmodSync(ghPath, 0o755);
-
-    const oldPath = process.env.PATH;
-    process.env.PATH = `${fakeDir}:${oldPath ?? ''}`;
-    try {
-      const result = await runXtrmFinish({ cwd: dir, pollIntervalMs: 1, timeoutMs: 20 });
-      expect(result.ok).toBe(true);
-      expect(result.message).toContain('merged');
-      const state = JSON.parse(readFileSync(path.join(dir, '.xtrm-session-state.json'), 'utf8'));
-      expect(state.phase).toBe('cleanup-done');
-    } finally {
-      process.env.PATH = oldPath;
-      rmSync(dir, { recursive: true, force: true });
-    }
-  });
-
-  it('uses claimed worktree path for gh/git phase steps when run from repo root', async () => {
-    const dir = mkdtempSync(path.join(os.tmpdir(), 'xtrm-finish-worktree-cwd-'));
-    const fakeDir = path.join(dir, 'fakebin');
-    mkdirSync(fakeDir, { recursive: true });
-    initRepo(dir);
-
-    const worktreePath = path.join(dir, '.worktrees', 'jaggers-agent-tools-1xa2');
-    spawnSync('git', ['worktree', 'add', worktreePath, '-b', 'feature/jaggers-agent-tools-1xa2'], {
-      cwd: dir,
-      stdio: 'pipe',
-    });
-
-    writeFileSync(path.join(dir, '.xtrm-session-state.json'), JSON.stringify({
-      issueId: 'jaggers-agent-tools-1xa2',
-      branch: 'feature/jaggers-agent-tools-1xa2',
-      worktreePath,
-      prNumber: 77,
-      prUrl: 'https://example.invalid/pr/77',
-      phase: 'waiting-merge',
-      conflictFiles: [],
-      startedAt: new Date().toISOString(),
-      lastChecked: new Date().toISOString(),
-    }), 'utf8');
-
-    const markerPath = path.join(dir, 'gh-cwd.txt');
-    const ghPath = path.join(fakeDir, 'gh');
-    writeFileSync(
-      ghPath,
-      `#!/usr/bin/env bash\nset -euo pipefail\nif [[ "$1" == "pr" && "$2" == "view" ]]; then\n  pwd > "${markerPath}"\n  echo '{"state":"MERGED","mergeStateStatus":"CLEAN","mergeable":"MERGEABLE"}'\n  exit 0\nfi\nexit 1\n`,
-    );
-    chmodSync(ghPath, 0o755);
-
-    const oldPath = process.env.PATH;
-    process.env.PATH = `${fakeDir}:${oldPath ?? ''}`;
-    try {
-      const result = await runXtrmFinish({ cwd: dir, pollIntervalMs: 1, timeoutMs: 20 });
-      expect(result.ok).toBe(true);
-      expect(readFileSync(markerPath, 'utf8').trim()).toBe(worktreePath);
-      expect(spawnSync('git', ['worktree', 'list'], { cwd: dir, encoding: 'utf8' }).stdout).not.toContain(worktreePath);
-      const state = JSON.parse(readFileSync(path.join(dir, '.xtrm-session-state.json'), 'utf8'));
-      expect(state.phase).toBe('cleanup-done');
-    } finally {
-      process.env.PATH = oldPath;
-      rmSync(dir, { recursive: true, force: true });
-    }
-  });
-
-  it('sets pending-cleanup when PR is not merged before timeout', async () => {
-    const dir = mkdtempSync(path.join(os.tmpdir(), 'xtrm-finish-timeout-'));
-    const fakeDir = path.join(dir, 'fakebin');
-    mkdirSync(fakeDir, { recursive: true });
-    initRepo(dir);
-
-    writeFileSync(path.join(dir, '.xtrm-session-state.json'), JSON.stringify({
-      issueId: 'jaggers-agent-tools-1xa2',
-      branch: 'feature/jaggers-agent-tools-1xa2',
-      worktreePath: '/tmp/nonexistent-worktree-path',
-      prNumber: 55,
-      prUrl: 'https://example.invalid/pr/55',
-      phase: 'waiting-merge',
-      conflictFiles: [],
-      startedAt: new Date().toISOString(),
-      lastChecked: new Date().toISOString(),
-    }), 'utf8');
-
-    const ghPath = path.join(fakeDir, 'gh');
-    writeFileSync(ghPath, `#!/usr/bin/env bash\nset -euo pipefail\nif [[ "$1" == "pr" && "$2" == "view" ]]; then\n  echo '{"state":"OPEN","mergeStateStatus":"BLOCKED","mergeable":"UNKNOWN"}'\n  exit 0\nfi\nexit 1\n`);
-    chmodSync(ghPath, 0o755);
-
-    const oldPath = process.env.PATH;
-    process.env.PATH = `${fakeDir}:${oldPath ?? ''}`;
-    try {
-      const result = await runXtrmFinish({ cwd: dir, pollIntervalMs: 1, timeoutMs: 10 });
-      expect(result.ok).toBe(false);
-      expect(result.message).toContain('Run xtrm finish when ready');
-      const state = JSON.parse(readFileSync(path.join(dir, '.xtrm-session-state.json'), 'utf8'));
-      expect(state.phase).toBe('pending-cleanup');
-    } finally {
-      process.env.PATH = oldPath;
-      rmSync(dir, { recursive: true, force: true });
-    }
-  });
-});