lsd-pi 1.0.0 → 1.1.1

package/src/resources/extensions/gsd/tests/integration/queue-reorder-e2e.test.ts

@@ -1,335 +0,0 @@
-/**
- * End-to-end integration tests for the Queue Reorder feature.
- *
- * Verifies the full chain: QUEUE-ORDER.json + findMilestoneIds() + deriveState()
- * + depends_on removal from CONTEXT.md files.
- *
- * These tests simulate what happens when a user reorders milestones and confirms:
- * 1. QUEUE-ORDER.json is written with the new order
- * 2. depends_on is removed from CONTEXT.md frontmatter
- * 3. deriveState() picks the correct milestone as active
- * 4. A fresh deriveState() call (simulating new session) also works
- */
-
-import { describe, test } from 'node:test';
-import assert from 'node:assert/strict';
-import { mkdtempSync, mkdirSync, rmSync, writeFileSync, readFileSync, existsSync } from 'node:fs';
-import { join } from 'node:path';
-import { tmpdir } from 'node:os';
-
-import { deriveState, invalidateStateCache } from '../../state.ts';
-import { findMilestoneIds } from '../../guided-flow.ts';
-import { saveQueueOrder, loadQueueOrder } from '../../queue-order.ts';
-import { parseContextDependsOn } from '../../files.ts';
-// ─── Fixture Helpers ───────────────────────────────────────────────────────
-
-function createFixtureBase(): string {
-  const base = mkdtempSync(join(tmpdir(), 'gsd-reorder-e2e-'));
-  mkdirSync(join(base, '.gsd', 'milestones'), { recursive: true });
-  return base;
-}
-
-function cleanup(base: string): void {
-  rmSync(base, { recursive: true, force: true });
-}
-
-function writeMilestoneDir(base: string, mid: string): void {
-  mkdirSync(join(base, '.gsd', 'milestones', mid), { recursive: true });
-}
-
-function writeContext(base: string, mid: string, frontmatter: string, body: string = ''): void {
-  const dir = join(base, '.gsd', 'milestones', mid);
-  mkdirSync(dir, { recursive: true });
-  const fm = frontmatter ? `---\n${frontmatter}\n---\n\n` : '';
-  writeFileSync(join(dir, `${mid}-CONTEXT.md`), `${fm}# ${mid}: Test\n\n${body}`);
-}
-
-function writeCompleteMilestone(base: string, mid: string): void {
-  const dir = join(base, '.gsd', 'milestones', mid);
-  mkdirSync(dir, { recursive: true });
-  writeFileSync(join(dir, `${mid}-ROADMAP.md`), `# ${mid}: Complete
-
-**Vision:** Done.
-
-## Slices
-
-- [x] **S01: Done** \`risk:low\` \`depends:[]\`
-  > After this: Done.
-`);
-  writeFileSync(join(dir, `${mid}-VALIDATION.md`), `---\nverdict: pass\nremediation_round: 0\n---\n\n# Validation\nPassed.`);
-  writeFileSync(join(dir, `${mid}-SUMMARY.md`), `# ${mid} Summary\n\nComplete.`);
-}
-
-function readContextFile(base: string, mid: string): string {
-  return readFileSync(join(base, '.gsd', 'milestones', mid, `${mid}-CONTEXT.md`), 'utf-8');
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// Test: Queue order changes milestone activation
-// ═══════════════════════════════════════════════════════════════════════════
-
-
-describe('queue-reorder-e2e', () => {
-test('E2E: queue-order changes active milestone', async () => {
-  const base = createFixtureBase();
-  try {
-    // Setup: M007 complete, M008 and M009 pending (no context, no roadmap)
-    writeCompleteMilestone(base, 'M007');
-    writeMilestoneDir(base, 'M008');
-    writeContext(base, 'M008', '', 'Multi-Session Parallel Orchestration');
-    writeMilestoneDir(base, 'M009');
-    writeContext(base, 'M009', '', 'Context-Budget Visibility');
-
-    // Without custom order: M008 comes first (numeric sort)
-    invalidateStateCache();
-    const stateBefore = await deriveState(base);
-    assert.deepStrictEqual(stateBefore.activeMilestone?.id, 'M008', 'before reorder: M008 is active');
-
-    // Save custom order: M009 before M008
-    saveQueueOrder(base, ['M009', 'M008']);
-
-    // With custom order: M009 should be active
-    invalidateStateCache();
-    const stateAfter = await deriveState(base);
-    assert.deepStrictEqual(stateAfter.activeMilestone?.id, 'M009', 'after reorder: M009 is active');
-
-    // findMilestoneIds respects the order
-    const ids = findMilestoneIds(base);
-    const m008Idx = ids.indexOf('M008');
-    const m009Idx = ids.indexOf('M009');
-    assert.ok(m009Idx < m008Idx, 'findMilestoneIds: M009 comes before M008');
-
-  } finally {
-    cleanup(base);
-  }
-});
-
-// ═══════════════════════════════════════════════════════════════════════════
-// Test: Reorder + depends_on removal = correct state
-// ═══════════════════════════════════════════════════════════════════════════
-test('E2E: reorder with depends_on removal', async () => {
-  const base = createFixtureBase();
-  try {
-    // Setup: M007 complete, M008 depends_on M009, M009 no deps
-    writeCompleteMilestone(base, 'M007');
-    writeContext(base, 'M008', 'depends_on: [M009]', 'Multi-Session Parallel');
-    writeContext(base, 'M009', '', 'Context-Budget Visibility');
-
-    // Before: M008 depends on M009, so deriveState skips M008, M009 is active
-    invalidateStateCache();
-    const stateBefore = await deriveState(base);
-    assert.deepStrictEqual(stateBefore.activeMilestone?.id, 'M009', 'before: M009 active (M008 dep-blocked)');
-
-    // Simulate reorder confirm: save order M009→M008, remove depends_on from M008
-    saveQueueOrder(base, ['M009', 'M008']);
-
-    // Remove depends_on from M008-CONTEXT.md (simulating what handleQueueReorder does)
-    const contextContent = readContextFile(base, 'M008');
-    const newContent = contextContent.replace(/---\ndepends_on: \[M009\]\n---\n\n/, '');
-    writeFileSync(join(base, '.gsd', 'milestones', 'M008', 'M008-CONTEXT.md'), newContent);
-
-    // Verify: depends_on is gone
-    const updatedContent = readContextFile(base, 'M008');
-    const deps = parseContextDependsOn(updatedContent);
-    assert.deepStrictEqual(deps.length, 0, 'depends_on removed from M008-CONTEXT.md');
-
-    // Verify: deriveState still picks M009 (it's first in queue order)
-    invalidateStateCache();
-    const stateAfter = await deriveState(base);
-    assert.deepStrictEqual(stateAfter.activeMilestone?.id, 'M009', 'after: M009 still active (first in queue)');
-
-    // Verify: M008 is now pending (not dep-blocked)
-    const m008Entry = stateAfter.registry.find(m => m.id === 'M008');
-    assert.deepStrictEqual(m008Entry?.status, 'pending', 'M008 is pending (not dep-blocked)');
-    assert.ok(!m008Entry?.dependsOn || m008Entry.dependsOn.length === 0, 'M008 has no dependsOn');
-
-  } finally {
-    cleanup(base);
-  }
-});
-
-// ═══════════════════════════════════════════════════════════════════════════
-// Test: Fresh deriveState (simulating new session) respects queue order
-// ═══════════════════════════════════════════════════════════════════════════
-test('E2E: fresh session respects queue order', async () => {
-  const base = createFixtureBase();
-  try {
-    writeCompleteMilestone(base, 'M007');
-    writeContext(base, 'M008', '', 'Parallel Orchestration');
-    writeContext(base, 'M009', '', 'Budget Visibility');
-
-    // Save queue order
-    saveQueueOrder(base, ['M009', 'M008']);
-
-    // Simulate fresh session — invalidate all caches
-    invalidateStateCache();
-
-    // Derive state — should read QUEUE-ORDER.json from disk
-    const state = await deriveState(base);
-    assert.deepStrictEqual(state.activeMilestone?.id, 'M009', 'fresh session: M009 is active');
-
-    // Verify queue order persisted
-    const order = loadQueueOrder(base);
-    assert.deepStrictEqual(order, ['M009', 'M008'], 'QUEUE-ORDER.json persisted correctly');
-
-  } finally {
-    cleanup(base);
-  }
-});
-
-// ═══════════════════════════════════════════════════════════════════════════
-// Test: Queue order with newly added milestones
-// ═══════════════════════════════════════════════════════════════════════════
-test('E2E: new milestones appended to queue', async () => {
-  const base = createFixtureBase();
-  try {
-    writeCompleteMilestone(base, 'M007');
-    writeContext(base, 'M008', '', 'Parallel');
-    writeContext(base, 'M009', '', 'Visibility');
-
-    // Custom order only has M009, M008
-    saveQueueOrder(base, ['M009', 'M008']);
-
-    // Add M010 (not in queue order)
-    writeContext(base, 'M010', '', 'New feature');
-
-    invalidateStateCache();
-    const ids = findMilestoneIds(base);
-
-    // M009 first, M008 second, M010 appended at end
-    const m009Idx = ids.indexOf('M009');
-    const m008Idx = ids.indexOf('M008');
-    const m010Idx = ids.indexOf('M010');
-    assert.ok(m009Idx < m008Idx, 'M009 before M008');
-    assert.ok(m008Idx < m010Idx, 'M008 before M010 (new milestone appended)');
-
-    // M009 is still active (first non-complete in queue order)
-    const state = await deriveState(base);
-    assert.deepStrictEqual(state.activeMilestone?.id, 'M009', 'M009 still active after M010 added');
-
-  } finally {
-    cleanup(base);
-  }
-});
-
-// ═══════════════════════════════════════════════════════════════════════════
-// Test: No queue order file = default numeric sort (backward compat)
-// ═══════════════════════════════════════════════════════════════════════════
-test('E2E: backward compat without QUEUE-ORDER.json', async () => {
-  const base = createFixtureBase();
-  try {
-    writeCompleteMilestone(base, 'M007');
-    writeContext(base, 'M008', '', 'Parallel');
-    writeContext(base, 'M009', '', 'Visibility');
-
-    // No QUEUE-ORDER.json — default numeric sort
-    invalidateStateCache();
-    const state = await deriveState(base);
-    assert.deepStrictEqual(state.activeMilestone?.id, 'M008', 'no queue order: M008 active (numeric)');
-
-    const ids = findMilestoneIds(base);
-    assert.ok(ids.indexOf('M008') < ids.indexOf('M009'), 'default sort: M008 before M009');
-
-  } finally {
-    cleanup(base);
-  }
-});
-
-// ═══════════════════════════════════════════════════════════════════════════
-// Test: non-milestone directories are filtered out (#1494)
-// ═══════════════════════════════════════════════════════════════════════════
-test('E2E: non-milestone directories filtered from findMilestoneIds (#1494)', () => {
-  const base = createFixtureBase();
-  try {
-    writeContext(base, 'M001', '', 'First');
-    writeContext(base, 'M002', '', 'Second');
-    // Create a rogue non-milestone directory
-    mkdirSync(join(base, '.gsd', 'milestones', 'slices'), { recursive: true });
-    mkdirSync(join(base, '.gsd', 'milestones', 'temp-backup'), { recursive: true });
-
-    invalidateStateCache();
-    const ids = findMilestoneIds(base);
-    assert.deepStrictEqual(ids.length, 2, 'only M001 and M002 returned');
-    assert.ok(!ids.includes('slices'), 'slices directory excluded');
-    assert.ok(!ids.includes('temp-backup'), 'temp-backup directory excluded');
-    assert.ok(ids.includes('M001'), 'M001 included');
-    assert.ok(ids.includes('M002'), 'M002 included');
-  } finally {
-    cleanup(base);
-  }
-});
-
-// ═══════════════════════════════════════════════════════════════════════════
-// Test: depends_on inline array format removal
-// ═══════════════════════════════════════════════════════════════════════════
-test('E2E: depends_on inline format preserved after partial removal', () => {
-  const base = createFixtureBase();
-  try {
-    writeCompleteMilestone(base, 'M007');
-    // M008 depends on both M009 and M010
-    writeContext(base, 'M008', 'depends_on: [M009, M010]', 'Parallel');
-    writeContext(base, 'M009', '', 'Visibility');
-    writeContext(base, 'M010', '', 'Other');
-
-    // Verify both deps are parsed
-    const contentBefore = readContextFile(base, 'M008');
-    const depsBefore = parseContextDependsOn(contentBefore);
-    assert.deepStrictEqual(depsBefore.length, 2, 'M008 has 2 deps before');
-
-    // Simulate removing only M009 dep (keep M010)
-    const content = readContextFile(base, 'M008');
-    const updated = content.replace('depends_on: [M009, M010]', 'depends_on: [M010]');
-    writeFileSync(join(base, '.gsd', 'milestones', 'M008', 'M008-CONTEXT.md'), updated);
-
-    // Verify only M010 remains
-    const contentAfter = readContextFile(base, 'M008');
-    const depsAfter = parseContextDependsOn(contentAfter);
-    assert.deepStrictEqual(depsAfter.length, 1, 'M008 has 1 dep after removal');
-    assert.deepStrictEqual(depsAfter[0], 'M010', 'remaining dep is M010');
-
-  } finally {
-    cleanup(base);
-  }
-});
-
-test('E2E: DB-backed path respects queue order (#2556)', async () => {
-    // Regression test for #2556: getActiveMilestoneId and deriveStateFromDb
-    // used lexicographic sort instead of queue order, causing a deadlock when
-    // the dispatch guard (which respects queue order) blocked completion.
-    const base = createFixtureBase();
-    try {
-      const { openDatabase, closeDatabase, insertMilestone, isDbAvailable } = await import('../../gsd-db.ts');
-      const dbPath = join(base, '.gsd', 'gsd.db');
-
-      // Create milestone directories (required for findMilestoneIds)
-      writeMilestoneDir(base, 'M006');
-      writeContext(base, 'M006', '', 'Earlier milestone');
-      writeMilestoneDir(base, 'M008');
-      writeContext(base, 'M008', '', 'Later milestone');
-
-      // Open DB and insert milestones
-      openDatabase(dbPath);
-      try {
-        insertMilestone({ id: 'M006', title: 'Earlier', status: 'active' });
-        insertMilestone({ id: 'M008', title: 'Later', status: 'active' });
-
-        // Set queue order: M008 should come FIRST (user reordered via /gsd queue)
-        saveQueueOrder(base, ['M008', 'M006']);
-
-        // deriveState should pick M008 (queue-first), not M006 (ID-first)
-        invalidateStateCache();
-        const state = await deriveState(base);
-        assert.equal(
-          state.activeMilestone?.id,
-          'M008',
-          'DB-backed deriveState must respect queue order — M008 is queued first',
-        );
-      } finally {
-        if (isDbAvailable()) closeDatabase();
-      }
-    } finally {
-      cleanup(base);
-    }
-});
-
-});

package/src/resources/extensions/gsd/tests/integration/quick-branch-lifecycle.test.ts

@@ -1,253 +0,0 @@
-/**
- * Tests for quick-task branch lifecycle:
- * - Branch creation → merge-back → cleanup
- * - Cross-session recovery via disk-persisted state
- * - captureIntegrationBranch guard against quick-task branches
- *
- * Relates to #1269, #1293.
- */
-
-import { describe, test } from 'node:test';
-import assert from 'node:assert/strict';
-import { mkdtempSync, mkdirSync, rmSync, writeFileSync, existsSync, readFileSync } from "node:fs";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-import { execSync } from "node:child_process";
-
-import { captureIntegrationBranch, getCurrentBranch } from "../../worktree.ts";
-import { readIntegrationBranch, QUICK_BRANCH_RE } from "../../git-service.ts";
-
-function run(command: string, cwd: string): string {
-  return execSync(command, { cwd, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" }).trim();
-}
-
-function createTestRepo(): string {
-  const repo = mkdtempSync(join(tmpdir(), "gsd-quick-lifecycle-"));
-  run("git init -b main", repo);
-  run(`git config user.name "GSD Test"`, repo);
-  run(`git config user.email "test@gsd.dev"`, repo);
-  mkdirSync(join(repo, ".gsd", "runtime"), { recursive: true });
-  mkdirSync(join(repo, ".gsd", "milestones", "M001"), { recursive: true });
-  writeFileSync(join(repo, "README.md"), "init\n");
-  run("git add -A", repo);
-  run(`git commit -m "init"`, repo);
-  return repo;
-}
-
-  // ═══════════════════════════════════════════════════════════════════════
-  // QUICK_BRANCH_RE
-  // ═══════════════════════════════════════════════════════════════════════
-
-
-describe('quick-branch-lifecycle', () => {
-test('QUICK_BRANCH_RE: matches quick-task branches', () => {
-  assert.ok(QUICK_BRANCH_RE.test("gsd/quick/1-fix-typo"), "matches standard quick branch");
-});
-
-  assert.ok(QUICK_BRANCH_RE.test("gsd/quick/42-some-long-slug-name"), "matches multi-digit quick branch");
-  assert.ok(!QUICK_BRANCH_RE.test("main"), "rejects main");
-  assert.ok(!QUICK_BRANCH_RE.test("gsd/M001/S01"), "rejects slice branch");
-  assert.ok(!QUICK_BRANCH_RE.test("gsd/quickly-something"), "rejects non-quick prefix");
-  assert.ok(!QUICK_BRANCH_RE.test("feature/gsd/quick/1"), "rejects nested prefix");
-  // ═══════════════════════════════════════════════════════════════════════
-  // captureIntegrationBranch: guard against quick-task branches
-  // ═══════════════════════════════════════════════════════════════════════
-test('captureIntegrationBranch: skips quick-task branches', () => {
-    const repo = createTestRepo();
-
-    // Create and checkout a quick-task branch
-    run("git checkout -b gsd/quick/1-fix-typo", repo);
-    assert.deepStrictEqual(getCurrentBranch(repo), "gsd/quick/1-fix-typo", "on quick branch");
-
-    captureIntegrationBranch(repo, "M001");
-
-    assert.deepStrictEqual(readIntegrationBranch(repo, "M001"), null,
-      "captureIntegrationBranch is a no-op on quick-task branches");
-
-    rmSync(repo, { recursive: true, force: true });
-});
-
-  // ─── Verify main is still recorded correctly ─────────────────────────
-test('captureIntegrationBranch: records main correctly', () => {
-    const repo = createTestRepo();
-
-    // Capture from main — should work normally
-    captureIntegrationBranch(repo, "M001");
-    assert.deepStrictEqual(readIntegrationBranch(repo, "M001"), "main",
-      "main is recorded as integration branch");
-
-    // Switch to quick branch — capture should be no-op (doesn't overwrite main)
-    run("git checkout -b gsd/quick/1-fix-typo", repo);
-    captureIntegrationBranch(repo, "M001");
-    assert.deepStrictEqual(readIntegrationBranch(repo, "M001"), "main",
-      "quick branch does not overwrite existing integration branch");
-
-    rmSync(repo, { recursive: true, force: true });
-});
-
-  // ─── Sequence: main → quick → back to main → capture ────────────────
-test('captureIntegrationBranch: correct after quick branch round-trip', () => {
-    const repo = createTestRepo();
-
-    // Simulate quick-task lifecycle: branch off, do work, return to main
-    run("git checkout -b gsd/quick/1-fix-typo", repo);
-    writeFileSync(join(repo, "fix.txt"), "fixed\n");
-    run("git add -A", repo);
-    run(`git commit -m "quick-fix"`, repo);
-    run("git checkout main", repo);
-    run("git merge --squash gsd/quick/1-fix-typo", repo);
-    run(`git commit -m "quick(Q1): fix-typo"`, repo);
-    run("git branch -D gsd/quick/1-fix-typo", repo);
-
-    // Now capture — should get main, not the deleted quick branch
-    captureIntegrationBranch(repo, "M002");
-    assert.deepStrictEqual(readIntegrationBranch(repo, "M002"), "main",
-      "after quick round-trip, main is captured correctly");
-
-    rmSync(repo, { recursive: true, force: true });
-});
-
-  // ═══════════════════════════════════════════════════════════════════════
-  // cleanupQuickBranch: in-memory path (same session)
-  // ═══════════════════════════════════════════════════════════════════════
-test('cleanupQuickBranch: merges back and cleans up (same session)', async () => {
-    const repo = createTestRepo();
-    const origCwd = process.cwd();
-
-    // Simulate what handleQuick does: create branch, set pending state
-    run("git checkout -b gsd/quick/1-fix-typo", repo);
-    writeFileSync(join(repo, "fix.txt"), "fixed\n");
-    run("git add -A", repo);
-    run(`git commit -m "quick-fix"`, repo);
-
-    // Write the disk state (simulating handleQuick's persistPendingReturn)
-    const returnState = {
-      basePath: repo,
-      originalBranch: "main",
-      quickBranch: "gsd/quick/1-fix-typo",
-      taskNum: 1,
-      slug: "fix-typo",
-      description: "fix typo",
-    };
-    const runtimeDir = join(repo, ".gsd", "runtime");
-    mkdirSync(runtimeDir, { recursive: true });
-    writeFileSync(join(runtimeDir, "quick-return.json"), JSON.stringify(returnState) + "\n");
-
-    // Switch cwd to repo so cleanupQuickBranch finds the disk state
-    process.chdir(repo);
-
-    // Import and call cleanupQuickBranch
-    // Use dynamic import to get a fresh module scope — the in-memory state
-    // won't be set, so it will fall through to disk recovery
-    const { cleanupQuickBranch } = await import("../../quick.ts");
-    const result = cleanupQuickBranch();
-
-    assert.ok(result, "cleanupQuickBranch returns true");
-    assert.deepStrictEqual(getCurrentBranch(repo), "main", "back on main after cleanup");
-
-    // Verify merge happened — fix.txt should exist on main
-    assert.ok(existsSync(join(repo, "fix.txt")), "fix.txt merged to main");
-
-    // Verify quick branch deleted
-    const branches = run("git branch", repo);
-    assert.ok(!branches.includes("gsd/quick/1-fix-typo"), "quick branch deleted");
-
-    // Verify disk state cleaned up
-    assert.ok(!existsSync(join(runtimeDir, "quick-return.json")), "quick-return.json removed");
-
-    process.chdir(origCwd);
-    rmSync(repo, { recursive: true, force: true });
-});
-
-  // ═══════════════════════════════════════════════════════════════════════
-  // cleanupQuickBranch: cross-session recovery from disk
-  // ═══════════════════════════════════════════════════════════════════════
-test('cleanupQuickBranch: recovers from disk state (cross-session)', async () => {
-    const repo = createTestRepo();
-    const origCwd = process.cwd();
-
-    // Simulate a crashed session: branch exists with work, disk state persisted,
-    // but in-memory state is gone (new process)
-    run("git checkout -b gsd/quick/2-add-docs", repo);
-    writeFileSync(join(repo, "docs.md"), "# Docs\n");
-    run("git add -A", repo);
-    run(`git commit -m "add-docs"`, repo);
-
-    // Write disk state manually (simulates what handleQuick would persist)
-    const runtimeDir = join(repo, ".gsd", "runtime");
-    mkdirSync(runtimeDir, { recursive: true });
-    writeFileSync(join(runtimeDir, "quick-return.json"), JSON.stringify({
-      basePath: repo,
-      originalBranch: "main",
-      quickBranch: "gsd/quick/2-add-docs",
-      taskNum: 2,
-      slug: "add-docs",
-      description: "add docs",
-    }) + "\n");
-
-    process.chdir(repo);
-
-    const { cleanupQuickBranch } = await import("../../quick.ts");
-    const result = cleanupQuickBranch();
-
-    assert.ok(result, "cross-session recovery returns true");
-    assert.deepStrictEqual(getCurrentBranch(repo), "main", "back on main after cross-session recovery");
-    assert.ok(existsSync(join(repo, "docs.md")), "docs.md merged to main");
-    assert.ok(!existsSync(join(runtimeDir, "quick-return.json")), "disk state cleaned up");
-
-    process.chdir(origCwd);
-    rmSync(repo, { recursive: true, force: true });
-});
-
-  // ═══════════════════════════════════════════════════════════════════════
-  // cleanupQuickBranch: no-op when no pending state
-  // ═══════════════════════════════════════════════════════════════════════
-test('cleanupQuickBranch: no-op without pending state', async () => {
-    const repo = createTestRepo();
-    const origCwd = process.cwd();
-    process.chdir(repo);
-
-    const { cleanupQuickBranch } = await import("../../quick.ts");
-    const result = cleanupQuickBranch();
-
-    assert.ok(!result, "returns false when no pending state");
-    assert.deepStrictEqual(getCurrentBranch(repo), "main", "stays on main");
-
-    process.chdir(origCwd);
-    rmSync(repo, { recursive: true, force: true });
-});
-
-  // ═══════════════════════════════════════════════════════════════════════
-  // End-to-end: quick branch does NOT contaminate integration branch
-  // ═══════════════════════════════════════════════════════════════════════
-test('E2E: quick branch does not contaminate integration branch', () => {
-    const repo = createTestRepo();
-
-    // 1. Record main as integration branch for M001
-    captureIntegrationBranch(repo, "M001");
-    assert.deepStrictEqual(readIntegrationBranch(repo, "M001"), "main", "M001 integration = main");
-
-    // 2. Start a quick task (branch off)
-    run("git checkout -b gsd/quick/1-fix-typo", repo);
-
-    // 3. Try to capture integration branch for M002 while on quick branch
-    captureIntegrationBranch(repo, "M002");
-    assert.deepStrictEqual(readIntegrationBranch(repo, "M002"), null,
-      "M002 integration NOT recorded from quick branch");
-
-    // 4. Return to main (simulate cleanupQuickBranch)
-    run("git checkout main", repo);
-
-    // 5. Now capture M002 from main — should work
-    captureIntegrationBranch(repo, "M002");
-    assert.deepStrictEqual(readIntegrationBranch(repo, "M002"), "main",
-      "M002 integration = main after returning from quick branch");
-
-    // 6. Verify M001 still intact
-    assert.deepStrictEqual(readIntegrationBranch(repo, "M001"), "main",
-      "M001 integration unchanged");
-
-    rmSync(repo, { recursive: true, force: true });
-});
-
-});