gsd-pi 2.33.1 → 2.34.0-dev.6769913

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

@@ -0,0 +1,281 @@
+/**
+ * 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 { 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 { createTestContext } from './test-helpers.ts';
+import { captureIntegrationBranch, getCurrentBranch } from "../worktree.ts";
+import { readIntegrationBranch, QUICK_BRANCH_RE } from "../git-service.ts";
+
+const { assertEq, assertTrue, report } = createTestContext();
+
+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;
+}
+
+async function main(): Promise<void> {
+
+  // ═══════════════════════════════════════════════════════════════════════
+  // QUICK_BRANCH_RE
+  // ═══════════════════════════════════════════════════════════════════════
+
+  console.log("\n=== QUICK_BRANCH_RE: matches quick-task branches ===");
+
+  assertTrue(QUICK_BRANCH_RE.test("gsd/quick/1-fix-typo"), "matches standard quick branch");
+  assertTrue(QUICK_BRANCH_RE.test("gsd/quick/42-some-long-slug-name"), "matches multi-digit quick branch");
+  assertTrue(!QUICK_BRANCH_RE.test("main"), "rejects main");
+  assertTrue(!QUICK_BRANCH_RE.test("gsd/M001/S01"), "rejects slice branch");
+  assertTrue(!QUICK_BRANCH_RE.test("gsd/quickly-something"), "rejects non-quick prefix");
+  assertTrue(!QUICK_BRANCH_RE.test("feature/gsd/quick/1"), "rejects nested prefix");
+
+  // ═══════════════════════════════════════════════════════════════════════
+  // captureIntegrationBranch: guard against quick-task branches
+  // ═══════════════════════════════════════════════════════════════════════
+
+  console.log("\n=== 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);
+    assertEq(getCurrentBranch(repo), "gsd/quick/1-fix-typo", "on quick branch");
+
+    captureIntegrationBranch(repo, "M001");
+
+    assertEq(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 ─────────────────────────
+
+  console.log("\n=== captureIntegrationBranch: records main correctly ===");
+
+  {
+    const repo = createTestRepo();
+
+    // Capture from main — should work normally
+    captureIntegrationBranch(repo, "M001");
+    assertEq(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");
+    assertEq(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 ────────────────
+
+  console.log("\n=== 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");
+    assertEq(readIntegrationBranch(repo, "M002"), "main",
+      "after quick round-trip, main is captured correctly");
+
+    rmSync(repo, { recursive: true, force: true });
+  }
+
+  // ═══════════════════════════════════════════════════════════════════════
+  // cleanupQuickBranch: in-memory path (same session)
+  // ═══════════════════════════════════════════════════════════════════════
+
+  console.log("\n=== cleanupQuickBranch: merges back and cleans up (same session) ===");
+
+  {
+    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();
+
+    assertTrue(result, "cleanupQuickBranch returns true");
+    assertEq(getCurrentBranch(repo), "main", "back on main after cleanup");
+
+    // Verify merge happened — fix.txt should exist on main
+    assertTrue(existsSync(join(repo, "fix.txt")), "fix.txt merged to main");
+
+    // Verify quick branch deleted
+    const branches = run("git branch", repo);
+    assertTrue(!branches.includes("gsd/quick/1-fix-typo"), "quick branch deleted");
+
+    // Verify disk state cleaned up
+    assertTrue(!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
+  // ═══════════════════════════════════════════════════════════════════════
+
+  console.log("\n=== cleanupQuickBranch: recovers from disk state (cross-session) ===");
+
+  {
+    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();
+
+    assertTrue(result, "cross-session recovery returns true");
+    assertEq(getCurrentBranch(repo), "main", "back on main after cross-session recovery");
+    assertTrue(existsSync(join(repo, "docs.md")), "docs.md merged to main");
+    assertTrue(!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
+  // ═══════════════════════════════════════════════════════════════════════
+
+  console.log("\n=== cleanupQuickBranch: no-op without pending state ===");
+
+  {
+    const repo = createTestRepo();
+    const origCwd = process.cwd();
+    process.chdir(repo);
+
+    const { cleanupQuickBranch } = await import("../quick.ts");
+    const result = cleanupQuickBranch();
+
+    assertTrue(!result, "returns false when no pending state");
+    assertEq(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
+  // ═══════════════════════════════════════════════════════════════════════
+
+  console.log("\n=== E2E: quick branch does not contaminate integration branch ===");
+
+  {
+    const repo = createTestRepo();
+
+    // 1. Record main as integration branch for M001
+    captureIntegrationBranch(repo, "M001");
+    assertEq(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");
+    assertEq(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");
+    assertEq(readIntegrationBranch(repo, "M002"), "main",
+      "M002 integration = main after returning from quick branch");
+
+    // 6. Verify M001 still intact
+    assertEq(readIntegrationBranch(repo, "M001"), "main",
+      "M001 integration unchanged");
+
+    rmSync(repo, { recursive: true, force: true });
+  }
+
+  report();
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exit(1);
+});

package/src/resources/extensions/gsd/tests/repo-identity-worktree.test.ts

@@ -0,0 +1,71 @@
+import { mkdtempSync, rmSync, writeFileSync, existsSync, lstatSync, realpathSync, mkdirSync, symlinkSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { execSync } from "node:child_process";
+
+import { externalGsdRoot, ensureGsdSymlink } from "../repo-identity.ts";
+import { createTestContext } from "./test-helpers.ts";
+
+const { assertEq, assertTrue, report } = createTestContext();
+
+function run(command: string, cwd: string): string {
+  return execSync(command, { cwd, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" }).trim();
+}
+
+async function main(): Promise<void> {
+  const base = realpathSync(mkdtempSync(join(tmpdir(), "gsd-repo-identity-")));
+  const stateDir = realpathSync(mkdtempSync(join(tmpdir(), "gsd-state-")));
+
+  try {
+    process.env.GSD_STATE_DIR = stateDir;
+
+    run("git init -b main", base);
+    run('git config user.name "Pi Test"', base);
+    run('git config user.email "pi@example.com"', base);
+    run('git remote add origin git@github.com:example/repo.git', base);
+    writeFileSync(join(base, "README.md"), "# Test Repo\n", "utf-8");
+    run("git add README.md", base);
+    run('git commit -m "chore: init"', base);
+
+    const worktreePath = join(base, ".gsd", "worktrees", "M001");
+    run(`git worktree add -b milestone/M001 ${worktreePath}`, base);
+
+    console.log("\n=== ensureGsdSymlink points worktree at main repo external state dir ===");
+    const expectedExternalState = externalGsdRoot(base);
+    const mainState = ensureGsdSymlink(base);
+    assertEq(mainState, realpathSync(join(base, ".gsd")), "ensureGsdSymlink(base) returns the current main repo .gsd target");
+    const worktreeState = ensureGsdSymlink(worktreePath);
+    assertEq(worktreeState, expectedExternalState, "worktree symlink target matches main repo external state dir");
+    assertTrue(existsSync(join(worktreePath, ".gsd")), "worktree .gsd exists");
+    assertTrue(lstatSync(join(worktreePath, ".gsd")).isSymbolicLink(), "worktree .gsd is a symlink");
+    assertEq(realpathSync(join(worktreePath, ".gsd")), realpathSync(expectedExternalState), "worktree .gsd symlink resolves to main repo external state dir");
+
+    console.log("\n=== ensureGsdSymlink heals stale worktree symlinks ===");
+    const staleState = join(stateDir, "projects", "stale-worktree-state");
+    mkdirSync(staleState, { recursive: true });
+    rmSync(join(worktreePath, ".gsd"), { recursive: true, force: true });
+    symlinkSync(staleState, join(worktreePath, ".gsd"), "junction");
+    const healedState = ensureGsdSymlink(worktreePath);
+    assertEq(healedState, expectedExternalState, "stale worktree symlink is repaired to canonical external state dir");
+    assertEq(realpathSync(join(worktreePath, ".gsd")), realpathSync(expectedExternalState), "healed worktree symlink resolves to canonical external state dir");
+
+    console.log("\n=== ensureGsdSymlink preserves worktree .gsd directories ===");
+    rmSync(join(worktreePath, ".gsd"), { recursive: true, force: true });
+    mkdirSync(join(worktreePath, ".gsd", "milestones"), { recursive: true });
+    writeFileSync(join(worktreePath, ".gsd", "milestones", "stale.txt"), "stale\n", "utf-8");
+    const preservedDirState = ensureGsdSymlink(worktreePath);
+    assertEq(preservedDirState, join(worktreePath, ".gsd"), "worktree .gsd directory is left in place for sync-based refresh");
+    assertTrue(lstatSync(join(worktreePath, ".gsd")).isDirectory(), "worktree .gsd directory remains a directory");
+    assertTrue(existsSync(join(worktreePath, ".gsd", "milestones", "stale.txt")), "existing worktree .gsd directory contents remain available for sync logic");
+  } finally {
+    delete process.env.GSD_STATE_DIR;
+    rmSync(base, { recursive: true, force: true });
+    rmSync(stateDir, { recursive: true, force: true });
+    report();
+  }
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exit(1);
+});

package/src/resources/extensions/gsd/tests/run-uat.test.ts

@@ -334,7 +334,7 @@ async function main(): Promise<void> {
         ].join('\n'),
       );
 
-      // human-experience UAT — should not dispatch
+      // human-experience UAT still dispatches, but auto-mode later pauses for manual review
       writeSliceFile(base, 'M001', 'S01', 'UAT', makeUatContent('human-experience'));
 
       const state = {
@@ -351,8 +351,8 @@ async function main(): Promise<void> {
       const result = await checkNeedsRunUat(base, 'M001', state as any, { uat_dispatch: true } as any);
       assertEq(
         result,
-        null,
-        'human-experience UAT is skipped — auto-mode only dispatches artifact-driven UATs',
+        { sliceId: 'S01', uatType: 'human-experience' },
+        'human-experience UAT dispatches so auto-mode can pause for manual review',
       );
     } finally {
       cleanup(base);

package/src/resources/extensions/gsd/tests/session-lock-regression.test.ts

@@ -11,6 +11,7 @@
  */
 
 import { mkdtempSync, mkdirSync, writeFileSync, rmSync, existsSync, readFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
 import { join } from 'node:path';
 import { tmpdir } from 'node:os';
 
@@ -26,6 +27,18 @@ import { gsdRoot } from '../paths.ts';
 import { createTestContext } from './test-helpers.ts';
 
 const { assertEq, assertTrue, report } = createTestContext();
+const require = createRequire(import.meta.url);
+
+function hasProperLockfile(): boolean {
+  try {
+    require("proper-lockfile");
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+const properLockfileAvailable = hasProperLockfile();
 
 async function main(): Promise<void> {
 
@@ -207,6 +220,57 @@ async function main(): Promise<void> {
     }
   }
 
+  // ─── 9. Re-entrant acquisition without explicit release ───────────────
+  console.log('\n=== 9. re-entrant acquire without explicit release ===');
+  {
+    const base = mkdtempSync(join(tmpdir(), 'gsd-session-lock-'));
+    mkdirSync(join(base, '.gsd'), { recursive: true });
+
+    try {
+      const r1 = acquireSessionLock(base);
+      assertTrue(r1.acquired, 'first acquisition succeeds');
+
+      const r2 = acquireSessionLock(base);
+      assertTrue(r2.acquired, 're-entrant acquisition succeeds');
+
+      const valid = validateSessionLock(base);
+      assertTrue(valid, 're-entrant acquisition does not corrupt validation state');
+
+      releaseSessionLock(base);
+    } finally {
+      rmSync(base, { recursive: true, force: true });
+    }
+  }
+
+  // ─── 10. Re-entrant acquisition refreshes lock artifacts ──────────────
+  console.log('\n=== 10. re-entrant acquire refreshes lock artifacts ===');
+  {
+    const base = mkdtempSync(join(tmpdir(), 'gsd-session-lock-'));
+    mkdirSync(join(base, '.gsd'), { recursive: true });
+
+    try {
+      const r1 = acquireSessionLock(base);
+      assertTrue(r1.acquired, 'first acquisition succeeds');
+
+      const lockDir = gsdRoot(base) + '.lock';
+      if (properLockfileAvailable) {
+        assertTrue(existsSync(lockDir), '.gsd.lock/ exists after first acquisition');
+      }
+
+      const r2 = acquireSessionLock(base);
+      assertTrue(r2.acquired, 'second acquisition succeeds');
+      if (properLockfileAvailable) {
+        assertTrue(existsSync(lockDir), '.gsd.lock/ exists after re-entrant acquisition');
+      }
+      assertTrue(validateSessionLock(base), 'lock remains valid after re-entrant acquisition');
+
+      releaseSessionLock(base);
+      assertTrue(!existsSync(lockDir), '.gsd.lock/ is removed after release');
+    } finally {
+      rmSync(base, { recursive: true, force: true });
+    }
+  }
+
   report();
 }
 

package/src/resources/extensions/gsd/tests/sidecar-queue.test.ts

@@ -0,0 +1,181 @@
+/**
+ * sidecar-queue.test.ts — Source-level contract tests for the sidecar queue pattern (S03).
+ *
+ * Verifies the structural invariants of the sidecar queue: the SidecarItem type,
+ * AutoSession sidecarQueue field, enqueue patterns in postUnitPostVerification,
+ * and dequeue logic in autoLoop. These are source-reading tests — no runtime required.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const SESSION_TS_PATH = join(__dirname, "..", "auto", "session.ts");
+const POST_UNIT_TS_PATH = join(__dirname, "..", "auto-post-unit.ts");
+const AUTO_LOOP_TS_PATH = join(__dirname, "..", "auto-loop.ts");
+
+function getSessionTsSource(): string {
+  return readFileSync(SESSION_TS_PATH, "utf-8");
+}
+
+function getPostUnitTsSource(): string {
+  return readFileSync(POST_UNIT_TS_PATH, "utf-8");
+}
+
+function getAutoLoopTsSource(): string {
+  return readFileSync(AUTO_LOOP_TS_PATH, "utf-8");
+}
+
+/**
+ * Extract the body of postUnitPostVerification from auto-post-unit.ts source.
+ */
+function getPostUnitPostVerificationBody(): string {
+  const source = getPostUnitTsSource();
+  const fnIdx = source.indexOf("export async function postUnitPostVerification");
+  assert.ok(fnIdx > -1, "postUnitPostVerification must exist in auto-post-unit.ts");
+  return source.slice(fnIdx);
+}
+
+// ─── SidecarItem type contract ───────────────────────────────────────────────
+
+test("SidecarItem type is exported from session.ts", () => {
+  const source = getSessionTsSource();
+  assert.ok(
+    source.includes("export interface SidecarItem"),
+    "session.ts must export the SidecarItem interface",
+  );
+});
+
+test("SidecarItem has required kind field with hook/triage/quick-task union", () => {
+  const source = getSessionTsSource();
+  const ifaceIdx = source.indexOf("export interface SidecarItem");
+  const ifaceBlock = source.slice(ifaceIdx, ifaceIdx + 500);
+  assert.ok(
+    ifaceBlock.includes('"hook"') && ifaceBlock.includes('"triage"') && ifaceBlock.includes('"quick-task"'),
+    "SidecarItem.kind must be a union of 'hook' | 'triage' | 'quick-task'",
+  );
+});
+
+// ─── AutoSession sidecarQueue field ──────────────────────────────────────────
+
+test("AutoSession declares sidecarQueue field", () => {
+  const source = getSessionTsSource();
+  assert.ok(
+    source.includes("sidecarQueue"),
+    "AutoSession must declare sidecarQueue property",
+  );
+  assert.ok(
+    source.includes("SidecarItem[]"),
+    "sidecarQueue must be typed as SidecarItem[]",
+  );
+});
+
+test("AutoSession resets sidecarQueue in reset()", () => {
+  const source = getSessionTsSource();
+  const resetIdx = source.indexOf("reset(): void");
+  assert.ok(resetIdx > -1, "AutoSession must have a reset() method");
+  const resetBlock = source.slice(resetIdx, resetIdx + 3000);
+  assert.ok(
+    resetBlock.includes("sidecarQueue"),
+    "reset() must clear sidecarQueue",
+  );
+});
+
+// ─── postUnitPostVerification: no inline dispatch ────────────────────────────
+
+test("postUnitPostVerification does not call pi.sendMessage", () => {
+  const body = getPostUnitPostVerificationBody();
+  assert.ok(
+    !body.includes("pi.sendMessage"),
+    "postUnitPostVerification must not call pi.sendMessage — all dispatch goes through sidecar queue",
+  );
+});
+
+test("postUnitPostVerification does not call newSession", () => {
+  const body = getPostUnitPostVerificationBody();
+  assert.ok(
+    !body.includes("s.cmdCtx.newSession") && !body.includes("cmdCtx.newSession"),
+    "postUnitPostVerification must not call newSession — all dispatch goes through sidecar queue",
+  );
+});
+
+// ─── postUnitPostVerification: sidecar enqueue for hooks ─────────────────────
+
+test("postUnitPostVerification pushes to sidecarQueue for hooks", () => {
+  const source = getPostUnitTsSource();
+  // Find the hook section (marked by the post-unit hooks comment)
+  const hookSectionStart = source.indexOf("// ── Post-unit hooks");
+  assert.ok(hookSectionStart > -1, "auto-post-unit.ts must have a post-unit hooks section");
+  const triageSectionStart = source.indexOf("// ── Triage check");
+  assert.ok(triageSectionStart > -1, "auto-post-unit.ts must have a triage check section");
+  const hookSection = source.slice(hookSectionStart, triageSectionStart);
+  assert.ok(
+    hookSection.includes("s.sidecarQueue.push("),
+    "hook section must push to s.sidecarQueue",
+  );
+  assert.ok(
+    hookSection.includes('kind: "hook"'),
+    "hook sidecar item must have kind: 'hook'",
+  );
+});
+
+// ─── postUnitPostVerification: sidecar enqueue for triage ────────────────────
+
+test("postUnitPostVerification pushes to sidecarQueue for triage", () => {
+  const source = getPostUnitTsSource();
+  const triageSectionStart = source.indexOf("// ── Triage check");
+  const quickTaskSectionStart = source.indexOf("// ── Quick-task dispatch");
+  assert.ok(triageSectionStart > -1, "auto-post-unit.ts must have a triage check section");
+  assert.ok(quickTaskSectionStart > -1, "auto-post-unit.ts must have a quick-task dispatch section");
+  const triageSection = source.slice(triageSectionStart, quickTaskSectionStart);
+  assert.ok(
+    triageSection.includes("s.sidecarQueue.push("),
+    "triage section must push to s.sidecarQueue",
+  );
+  assert.ok(
+    triageSection.includes('kind: "triage"'),
+    "triage sidecar item must have kind: 'triage'",
+  );
+});
+
+// ─── postUnitPostVerification: sidecar enqueue for quick-tasks ───────────────
+
+test("postUnitPostVerification pushes to sidecarQueue for quick-tasks", () => {
+  const source = getPostUnitTsSource();
+  const quickTaskSectionStart = source.indexOf("// ── Quick-task dispatch");
+  assert.ok(quickTaskSectionStart > -1, "auto-post-unit.ts must have a quick-task dispatch section");
+  const quickTaskSection = source.slice(quickTaskSectionStart);
+  assert.ok(
+    quickTaskSection.includes("s.sidecarQueue.push("),
+    "quick-task section must push to s.sidecarQueue",
+  );
+  assert.ok(
+    quickTaskSection.includes('kind: "quick-task"'),
+    "quick-task sidecar item must have kind: 'quick-task'",
+  );
+});
+
+// ─── autoLoop: sidecar dequeue ───────────────────────────────────────────────
+
+test("autoLoop has sidecar-dequeue phase", () => {
+  const source = getAutoLoopTsSource();
+  assert.ok(
+    source.includes('"sidecar-dequeue"'),
+    "autoLoop must log phase: 'sidecar-dequeue' when draining the sidecar queue",
+  );
+});
+
+test("autoLoop does not have inline dispatch loop", () => {
+  const source = getAutoLoopTsSource();
+  assert.ok(
+    !source.includes('"await-inline-dispatch"'),
+    "autoLoop must not contain 'await-inline-dispatch' — replaced by sidecar queue",
+  );
+  assert.ok(
+    !source.includes("while (inlineResult"),
+    "autoLoop must not contain a while(inlineResult...) loop — replaced by sidecar queue drain",
+  );
+});

package/src/resources/extensions/gsd/tests/stale-worktree-cwd.test.ts

@@ -28,9 +28,6 @@ function createTempRepo(): string {
   run("git config user.email test@test.com", dir);
   run("git config user.name Test", dir);
   writeFileSync(join(dir, "README.md"), "# test\n");
-  // Mirror production: .gsd/worktrees/ is gitignored so autoCommitDirtyState
-  // doesn't pick up the worktrees directory as dirty state (#1127 fix).
-  writeFileSync(join(dir, ".gitignore"), ".gsd/worktrees/\n");
   run("git add .", dir);
   run("git commit -m init", dir);
   run("git branch -M main", dir);

package/src/resources/extensions/gsd/tests/token-profile.test.ts

@@ -36,16 +36,16 @@ const typesSrc = readFileSync(join(__dirname, "..", "types.ts"), "utf-8");
 
 test("types: TokenProfile type exported with budget/balanced/quality", () => {
   assert.ok(typesSrc.includes("export type TokenProfile"), "TokenProfile should be exported");
-  assert.ok(typesSrc.includes("'budget'"), "should include budget");
-  assert.ok(typesSrc.includes("'balanced'"), "should include balanced");
-  assert.ok(typesSrc.includes("'quality'"), "should include quality");
+  assert.match(typesSrc, /["']budget["']/, "should include budget");
+  assert.match(typesSrc, /["']balanced["']/, "should include balanced");
+  assert.match(typesSrc, /["']quality["']/, "should include quality");
 });
 
 test("types: InlineLevel type exported with full/standard/minimal", () => {
   assert.ok(typesSrc.includes("export type InlineLevel"), "InlineLevel should be exported");
-  assert.ok(typesSrc.includes("'full'"), "should include full");
-  assert.ok(typesSrc.includes("'standard'"), "should include standard");
-  assert.ok(typesSrc.includes("'minimal'"), "should include minimal");
+  assert.match(typesSrc, /["']full["']/, "should include full");
+  assert.match(typesSrc, /["']standard["']/, "should include standard");
+  assert.match(typesSrc, /["']minimal["']/, "should include minimal");
 });
 
 test("types: PhaseSkipPreferences interface exported", () => {