gsd-pi 2.44.0-dev.d25d507 → 2.45.0-dev.1afbdaa

package/src/resources/extensions/gsd/rethink.ts

@@ -0,0 +1,154 @@
+/**
+ * GSD Rethink — Conversational project reorganization.
+ *
+ * Collects a snapshot of all milestones (status, dependencies, slice progress,
+ * queue order) and dispatches a prompt that turns Claude into a reorganization
+ * assistant. Claude can then reorder, park, unpark, discard, or add milestones
+ * through conversation.
+ */
+
+import type { ExtensionAPI, ExtensionCommandContext } from "@gsd/pi-coding-agent";
+import { existsSync } from "node:fs";
+
+import { isAutoActive } from "./auto.js";
+import { deriveState } from "./state.js";
+import { gsdRoot } from "./paths.js";
+import { findMilestoneIds } from "./milestone-ids.js";
+import { loadQueueOrder, validateQueueOrder } from "./queue-order.js";
+import { isParked, getParkedReason } from "./milestone-actions.js";
+import { getMilestoneSlices, isDbAvailable } from "./gsd-db.js";
+import { buildExistingMilestonesContext } from "./guided-flow-queue.js";
+import { loadPrompt } from "./prompt-loader.js";
+
+// ─── Entry Point ──────────────────────────────────────────────────────────────
+
+export async function handleRethink(
+  _args: string,
+  ctx: ExtensionCommandContext,
+  pi: ExtensionAPI,
+): Promise<void> {
+  if (isAutoActive()) {
+    ctx.ui.notify("Cannot rethink while auto-mode is active. Stop auto-mode first.", "error");
+    return;
+  }
+
+  const basePath = process.cwd();
+  const root = gsdRoot(basePath);
+  if (!existsSync(root)) {
+    ctx.ui.notify("No GSD project found. Run /gsd init first.", "warning");
+    return;
+  }
+
+  ctx.ui.notify("Building project snapshot for rethink...", "info");
+
+  const state = await deriveState(basePath);
+  const milestoneIds = findMilestoneIds(basePath);
+
+  if (milestoneIds.length === 0) {
+    ctx.ui.notify("No milestones exist yet. Nothing to rethink.", "warning");
+    return;
+  }
+
+  const queueOrder = loadQueueOrder(basePath);
+  const rethinkData = buildRethinkData(basePath, milestoneIds, state, queueOrder);
+  const existingMilestonesContext = await buildExistingMilestonesContext(basePath, milestoneIds, state);
+
+  const content = loadPrompt("rethink", {
+    rethinkData,
+    existingMilestonesContext,
+  });
+
+  pi.sendMessage(
+    { customType: "gsd-rethink", content, display: false },
+    { triggerTurn: true },
+  );
+}
+
+// ─── Data Builder ─────────────────────────────────────────────────────────────
+
+function buildRethinkData(
+  basePath: string,
+  milestoneIds: string[],
+  state: Awaited<ReturnType<typeof deriveState>>,
+  queueOrder: string[] | null,
+): string {
+  const lines: string[] = [];
+  const dbAvailable = isDbAvailable();
+
+  // ── Summary stats ───────────────────────────────────────────────────
+  const counts = { complete: 0, active: 0, pending: 0, parked: 0 };
+  for (const entry of state.registry) {
+    if (entry.status in counts) counts[entry.status as keyof typeof counts]++;
+  }
+
+  lines.push("### Summary");
+  lines.push(`${counts.complete} complete, ${counts.active} active, ${counts.pending} pending, ${counts.parked} parked — ${milestoneIds.length} total`);
+  lines.push(`Queue order source: ${queueOrder ? "explicit QUEUE-ORDER.json" : "default numeric (by ID)"}`);
+  if (state.activeMilestone) {
+    lines.push(`Active milestone: ${state.activeMilestone}`);
+  }
+  lines.push("");
+
+  // ── Milestone table ─────────────────────────────────────────────────
+  lines.push("### Execution Order");
+  lines.push("");
+  lines.push("| # | ID | Title | Status | Dependencies | Slices |");
+  lines.push("|---|-----|-------|--------|--------------|--------|");
+
+  for (let i = 0; i < milestoneIds.length; i++) {
+    const mid = milestoneIds[i];
+    const entry = state.registry.find(m => m.id === mid);
+    const title = entry?.title ?? mid;
+    const status = entry?.status ?? "unknown";
+    const deps = entry?.dependsOn?.length ? entry.dependsOn.join(", ") : "—";
+
+    let sliceInfo = "—";
+    if (dbAvailable && status !== "complete") {
+      const slices = getMilestoneSlices(mid);
+      if (slices.length > 0) {
+        const done = slices.filter(s => s.status === "complete").length;
+        sliceInfo = `${done}/${slices.length} complete`;
+      }
+    }
+
+    // Add parked reason if applicable
+    let statusDisplay = status;
+    if (status === "parked") {
+      const reason = getParkedReason(basePath, mid);
+      if (reason) statusDisplay = `parked (${reason})`;
+    }
+
+    lines.push(`| ${i + 1} | ${mid} | ${title} | ${statusDisplay} | ${deps} | ${sliceInfo} |`);
+  }
+
+  // ── Dependency validation ───────────────────────────────────────────
+  const pendingIds = milestoneIds.filter(mid => {
+    const entry = state.registry.find(m => m.id === mid);
+    return entry?.status !== "complete";
+  });
+
+  const completedIds = new Set(
+    state.registry.filter(m => m.status === "complete").map(m => m.id),
+  );
+
+  const depsMap = new Map<string, string[]>();
+  for (const entry of state.registry) {
+    if (entry.dependsOn?.length) {
+      depsMap.set(entry.id, entry.dependsOn);
+    }
+  }
+
+  if (pendingIds.length > 0 && depsMap.size > 0) {
+    const validation = validateQueueOrder(pendingIds, depsMap, completedIds);
+
+    if (validation.violations.length > 0) {
+      lines.push("");
+      lines.push("### Dependency Issues");
+      for (const v of validation.violations) {
+        lines.push(`- **${v.type}**: ${v.message}`);
+      }
+    }
+  }
+
+  return lines.join("\n");
+}

package/src/resources/extensions/gsd/session-lock.ts

@@ -32,7 +32,6 @@ export interface SessionLockData {
   unitType: string;
   unitId: string;
   unitStartedAt: string;
-  completedUnits: number;
   sessionFile?: string;
 }
 
@@ -205,7 +204,6 @@ export function acquireSessionLock(basePath: string): SessionLockResult {
     unitType: "starting",
     unitId: "bootstrap",
     unitStartedAt: new Date().toISOString(),
-    completedUnits: 0,
   };
 
   let lockfile: typeof import("proper-lockfile");
@@ -379,7 +377,6 @@ export function updateSessionLock(
   basePath: string,
   unitType: string,
   unitId: string,
-  completedUnits: number,
   sessionFile?: string,
 ): void {
   if (_lockedPath !== basePath && _lockedPath !== null) return;
@@ -392,7 +389,6 @@ export function updateSessionLock(
       unitType,
       unitId,
       unitStartedAt: new Date().toISOString(),
-      completedUnits,
       sessionFile,
     };
     atomicWriteSync(lp, JSON.stringify(data, null, 2));

package/src/resources/extensions/gsd/state.ts

@@ -48,6 +48,7 @@ import {
   getSliceTasks,
   getReplanHistory,
   getSlice,
+  insertMilestone,
   type MilestoneRow,
   type SliceRow,
   type TaskRow,
@@ -117,6 +118,11 @@ interface StateCache {
 const CACHE_TTL_MS = 100;
 let _stateCache: StateCache | null = null;
 
+// ── Telemetry counters for derive-path observability ────────────────────────
+let _telemetry = { dbDeriveCount: 0, markdownDeriveCount: 0 };
+export function getDeriveTelemetry() { return { ..._telemetry }; }
+export function resetDeriveTelemetry() { _telemetry = { dbDeriveCount: 0, markdownDeriveCount: 0 }; }
+
 /**
  * Invalidate the deriveState() cache. Call this whenever planning files on disk
  * may have changed (unit completion, merges, file writes).
@@ -203,12 +209,15 @@ export async function deriveState(basePath: string): Promise<GSDState> {
       const stopDbTimer = debugTime("derive-state-db");
       result = await deriveStateFromDb(basePath);
       stopDbTimer({ phase: result.phase, milestone: result.activeMilestone?.id });
+      _telemetry.dbDeriveCount++;
     } else {
       // DB open but empty hierarchy tables — pre-migration project, use filesystem
       result = await _deriveStateImpl(basePath);
+      _telemetry.markdownDeriveCount++;
     }
   } else {
     result = await _deriveStateImpl(basePath);
+    _telemetry.markdownDeriveCount++;
   }
 
   stopTimer({ phase: result.phase, milestone: result.activeMilestone?.id });
@@ -257,7 +266,46 @@ function isStatusDone(status: string): boolean {
 export async function deriveStateFromDb(basePath: string): Promise<GSDState> {
   const requirements = parseRequirementCounts(await loadFile(resolveGsdRootFile(basePath, "REQUIREMENTS")));
 
-  const allMilestones = getAllMilestones();
+  let allMilestones = getAllMilestones();
+
+  // Incremental disk→DB sync: milestone directories created outside the DB
+  // write path (via /gsd queue, manual mkdir, or complete-milestone writing the
+  // next CONTEXT.md) are never inserted by the initial migration guard in
+  // auto-start.ts because that guard only runs when gsd.db doesn't exist yet.
+  // Reconcile here so deriveStateFromDb never silently misses queued milestones.
+  // insertMilestone uses INSERT OR IGNORE, so this is safe to call every time.
+  const dbIdSet = new Set(allMilestones.map(m => m.id));
+  const diskIds = findMilestoneIds(basePath);
+  let synced = false;
+  for (const diskId of diskIds) {
+    if (!dbIdSet.has(diskId) && !isGhostMilestone(basePath, diskId)) {
+      insertMilestone({ id: diskId, status: 'active' });
+      synced = true;
+    }
+  }
+  if (synced) allMilestones = getAllMilestones();
+
+  // Reconcile: discover milestones that exist on disk but are missing from
+  // the DB. This happens when milestones were created before the DB migration
+  // or were manually added to the filesystem. Without this, disk-only
+  // milestones are invisible after migration (#2416).
+  const dbMilestoneIds = new Set(allMilestones.map(m => m.id));
+  const diskMilestoneIds = findMilestoneIds(basePath);
+  for (const diskId of diskMilestoneIds) {
+    if (!dbMilestoneIds.has(diskId)) {
+      // Synthesize a minimal MilestoneRow for the disk-only milestone.
+      // Title and status will be resolved from disk files in the loop below.
+      allMilestones.push({
+        id: diskId,
+        title: diskId,
+        status: 'active',
+        depends_on: [] as string[],
+        created_at: new Date().toISOString(),
+      } as MilestoneRow);
+    }
+  }
+  // Re-sort so milestones are in canonical order after injection
+  allMilestones.sort((a, b) => milestoneIdSort(a.id, b.id));
 
   // Parallel worker isolation: when locked, filter to just the locked milestone
   const milestoneLock = process.env.GSD_MILESTONE_LOCK;

package/src/resources/extensions/gsd/sync-lock.ts

@@ -0,0 +1,94 @@
+// GSD Extension — Advisory Sync Lock
+// Prevents concurrent worktree syncs from colliding via a simple file lock.
+// Stale locks (mtime > 60s) are auto-overridden. Lock acquisition waits up
+// to 5 seconds then skips non-fatally.
+
+import { existsSync, statSync, unlinkSync } from "node:fs";
+import { join } from "node:path";
+import { atomicWriteSync } from "./atomic-write.js";
+
+const STALE_THRESHOLD_MS = 60_000; // 60 seconds
+const DEFAULT_TIMEOUT_MS = 5_000;  // 5 seconds
+const SPIN_INTERVAL_MS = 100;      // 100ms polling interval
+
+// SharedArrayBuffer for synchronous sleep via Atomics.wait
+const SLEEP_BUFFER = new SharedArrayBuffer(4);
+const SLEEP_VIEW = new Int32Array(SLEEP_BUFFER);
+
+function lockFilePath(basePath: string): string {
+  return join(basePath, ".gsd", "sync.lock");
+}
+
+function sleepSync(ms: number): void {
+  Atomics.wait(SLEEP_VIEW, 0, 0, ms);
+}
+
+/**
+ * Acquire an advisory sync lock for the given basePath.
+ * Returns { acquired: true } on success, { acquired: false } after timeout.
+ *
+ * - Creates lock file at {basePath}/.gsd/sync.lock with JSON { pid, acquired_at }
+ * - If lock exists and mtime > 60s (stale), overrides it
+ * - If lock exists and not stale, spins up to timeoutMs before giving up
+ */
+export function acquireSyncLock(
+  basePath: string,
+  timeoutMs: number = DEFAULT_TIMEOUT_MS,
+): { acquired: boolean } {
+  const lp = lockFilePath(basePath);
+  const deadline = Date.now() + timeoutMs;
+
+  while (true) {
+    // Check if lock file exists
+    if (existsSync(lp)) {
+      // Check staleness
+      try {
+        const stat = statSync(lp);
+        const age = Date.now() - stat.mtimeMs;
+        if (age > STALE_THRESHOLD_MS) {
+          // Stale lock — override it
+          try { unlinkSync(lp); } catch { /* race: already removed */ }
+        } else {
+          // Lock is held and not stale — wait or give up
+          if (Date.now() >= deadline) {
+            return { acquired: false };
+          }
+          sleepSync(SPIN_INTERVAL_MS);
+          continue;
+        }
+      } catch {
+        // stat failed (file removed between exists check and stat) — try to acquire
+      }
+    }
+
+    // Lock file does not exist (or was just removed) — try to write it
+    try {
+      const lockData = {
+        pid: process.pid,
+        acquired_at: new Date().toISOString(),
+      };
+      atomicWriteSync(lp, JSON.stringify(lockData, null, 2));
+      return { acquired: true };
+    } catch {
+      // Write failed (race condition with another process) — retry or give up
+      if (Date.now() >= deadline) {
+        return { acquired: false };
+      }
+      sleepSync(SPIN_INTERVAL_MS);
+    }
+  }
+}
+
+/**
+ * Release the advisory sync lock. No-op if lock file does not exist.
+ */
+export function releaseSyncLock(basePath: string): void {
+  const lp = lockFilePath(basePath);
+  try {
+    if (existsSync(lp)) {
+      unlinkSync(lp);
+    }
+  } catch {
+    // Non-fatal — lock may have been released by another process
+  }
+}

package/src/resources/extensions/gsd/tests/auto-lock-creation.test.ts

@@ -27,7 +27,7 @@ test("writeLock creates auto.lock with correct structure", () => {
   const dir = mkdtempSync(join(tmpdir(), "gsd-lock-test-"));
   mkdirSync(join(dir, ".gsd"), { recursive: true });
 
-  writeLock(dir, "starting", "M001", 0);
+  writeLock(dir, "starting", "M001");
 
   const lockPath = join(dir, ".gsd", "auto.lock");
   assert.ok(existsSync(lockPath), "auto.lock should exist after writeLock");
@@ -36,7 +36,6 @@ test("writeLock creates auto.lock with correct structure", () => {
   assert.equal(data.pid, process.pid, "lock should contain current PID");
   assert.equal(data.unitType, "starting", "lock should contain unit type");
   assert.equal(data.unitId, "M001", "lock should contain unit ID");
-  assert.equal(data.completedUnits, 0, "lock should show 0 completed units");
   assert.ok(data.startedAt, "lock should have startedAt timestamp");
 
   rmSync(dir, { recursive: true, force: true });
@@ -46,13 +45,12 @@ test("writeLock updates existing lock with new unit info", () => {
   const dir = mkdtempSync(join(tmpdir(), "gsd-lock-test-"));
   mkdirSync(join(dir, ".gsd"), { recursive: true });
 
-  writeLock(dir, "starting", "M001", 0);
-  writeLock(dir, "execute-task", "M001/S01/T01", 2, "/tmp/session.jsonl");
+  writeLock(dir, "starting", "M001");
+  writeLock(dir, "execute-task", "M001/S01/T01", "/tmp/session.jsonl");
 
   const data = JSON.parse(readFileSync(join(dir, ".gsd", "auto.lock"), "utf-8"));
   assert.equal(data.unitType, "execute-task", "lock should be updated to new unit type");
   assert.equal(data.unitId, "M001/S01/T01", "lock should be updated to new unit ID");
-  assert.equal(data.completedUnits, 2, "completed count should be updated");
   assert.equal(data.sessionFile, "/tmp/session.jsonl", "session file should be recorded");
 
   rmSync(dir, { recursive: true, force: true });
@@ -74,13 +72,12 @@ test("readCrashLock returns lock data when file exists", () => {
   const dir = mkdtempSync(join(tmpdir(), "gsd-lock-test-"));
   mkdirSync(join(dir, ".gsd"), { recursive: true });
 
-  writeLock(dir, "plan-milestone", "M002", 5);
+  writeLock(dir, "plan-milestone", "M002");
   const lock = readCrashLock(dir);
 
   assert.ok(lock, "should return lock data");
   assert.equal(lock!.unitType, "plan-milestone");
   assert.equal(lock!.unitId, "M002");
-  assert.equal(lock!.completedUnits, 5);
 
   rmSync(dir, { recursive: true, force: true });
 });
@@ -91,7 +88,7 @@ test("clearLock removes the lock file", () => {
   const dir = mkdtempSync(join(tmpdir(), "gsd-lock-test-"));
   mkdirSync(join(dir, ".gsd"), { recursive: true });
 
-  writeLock(dir, "starting", "M001", 0);
+  writeLock(dir, "starting", "M001");
   assert.ok(existsSync(join(dir, ".gsd", "auto.lock")), "lock should exist before clear");
 
   clearLock(dir);
@@ -139,7 +136,6 @@ test("isLockProcessAlive returns false for dead PID", () => {
     unitType: "execute-task",
     unitId: "M001/S01/T01",
     unitStartedAt: new Date().toISOString(),
-    completedUnits: 0,
   };
   assert.equal(isLockProcessAlive(lock), false, "dead PID should return false");
 });
@@ -151,7 +147,6 @@ test("isLockProcessAlive returns false for own PID (recycled)", () => {
     unitType: "execute-task",
     unitId: "M001/S01/T01",
     unitStartedAt: new Date().toISOString(),
-    completedUnits: 0,
   };
   assert.equal(isLockProcessAlive(lock), false, "own PID should return false (recycled)");
 });
@@ -163,7 +158,6 @@ test("isLockProcessAlive returns false for invalid PID", () => {
     unitType: "execute-task",
     unitId: "M001/S01/T01",
     unitStartedAt: new Date().toISOString(),
-    completedUnits: 0,
   };
   assert.equal(isLockProcessAlive(lock), false, "negative PID should return false");
 });
@@ -183,7 +177,6 @@ test("lock file enables cross-process auto-mode detection", () => {
     unitType: "execute-task",
     unitId: "M001/S01/T02",
     unitStartedAt: new Date().toISOString(),
-    completedUnits: 3,
   };
   writeFileSync(join(dir, ".gsd", "auto.lock"), JSON.stringify(lockData, null, 2));
 
@@ -209,7 +202,6 @@ test("stale lock from dead process is detected as not alive", () => {
     unitType: "plan-slice",
     unitId: "M001/S02",
     unitStartedAt: "2026-03-01T00:05:00Z",
-    completedUnits: 1,
   };
   writeFileSync(join(dir, ".gsd", "auto.lock"), JSON.stringify(lockData, null, 2));
 

package/src/resources/extensions/gsd/tests/auto-loop.test.ts

@@ -367,9 +367,6 @@ function makeMockDeps(
     getPriorSliceCompletionBlocker: () => null,
     getMainBranch: () => "main",
     closeoutUnit: async () => {},
-    verifyExpectedArtifact: () => true,
-    clearUnitRuntimeRecord: () => {},
-    writeUnitRuntimeRecord: () => {},
     recordOutcome: () => {},
     writeLock: () => {},
     captureAvailableSkills: () => {},
@@ -713,10 +710,10 @@ test("crash lock records session file from AFTER newSession, not before (#1710)"
         prompt: "do the thing",
       };
     },
-    writeLock: (_base: string, _ut: string, _uid: string, _count: number, sessionFile?: string) => {
+    writeLock: (_base: string, _ut: string, _uid: string, sessionFile?: string) => {
       writeLockCalls.push({ sessionFile });
     },
-    updateSessionLock: (_base: string, _ut: string, _uid: string, _count: number, sessionFile?: string) => {
+    updateSessionLock: (_base: string, _ut: string, _uid: string, sessionFile?: string) => {
       updateSessionLockCalls.push({ sessionFile });
     },
     getSessionFile: (ctxArg: any) => {
@@ -1104,7 +1101,7 @@ test("auto.ts startAuto calls autoLoop (not dispatchNextUnit as first dispatch)"
   );
 });
 
-test("startAuto calls selfHealRuntimeRecords before autoLoop (#1727)", () => {
+test("startAuto calls selfHealRuntimeRecords before autoLoop (#1727)", { skip: "selfHealRuntimeRecords moved to crash-recovery pipeline in v3" }, () => {
   const src = readFileSync(
     resolve(import.meta.dirname, "..", "auto.ts"),
     "utf-8",
@@ -1990,7 +1987,6 @@ test("autoLoop does NOT reject non-execute-task units with 0 tool calls (#1833)"
       });
     },
     getLedger: () => mockLedger,
-    verifyExpectedArtifact: () => true,
     postUnitPostVerification: async () => {
       deps.callLog.push("postUnitPostVerification");
       s.active = false;
@@ -2014,10 +2010,10 @@ test("autoLoop does NOT reject non-execute-task units with 0 tool calls (#1833)"
     "should NOT flag non-execute-task units with 0 tool calls",
   );
 
-  // The unit should have been added to completedUnits normally
+  // Verify the loop ran to completion (postUnitPostVerification was called)
   assert.ok(
-    s.completedUnits.length >= 1,
-    "complete-slice with 0 tool calls should still be marked as completed",
+    deps.callLog.includes("postUnitPostVerification"),
+    "complete-slice with 0 tool calls should still complete the post-unit pipeline",
   );
 });
 

package/src/resources/extensions/gsd/tests/auto-pr-bugs.test.ts

@@ -0,0 +1,88 @@
+/**
+ * auto-pr-bugs.test.ts — Regression tests for #2302.
+ *
+ * Three interacting bugs prevented auto_pr from ever creating a PR:
+ * 1. auto_pr was gated on `pushed` (which requires auto_push)
+ * 2. Milestone branch was not pushed to remote before PR creation
+ * 3. createDraftPR in git-service.ts lacked --head/--base parameters
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
+// ─── Bug 1: auto_pr should not depend on auto_push / pushed flag ────────────
+
+const autoWorktreeSrcPath = join(import.meta.dirname, "..", "auto-worktree.ts");
+const autoWorktreeSrc = readFileSync(autoWorktreeSrcPath, "utf-8");
+
+test("#2302 bug 1: auto_pr condition should not require pushed flag", () => {
+  // Find the auto_pr block in mergeMilestoneToMain
+  const autoPrIdx = autoWorktreeSrc.indexOf("auto_pr");
+  assert.ok(autoPrIdx !== -1, "auto_pr reference exists in auto-worktree.ts");
+
+  // Get context around the auto_pr check
+  const lineStart = autoWorktreeSrc.lastIndexOf("\n", autoPrIdx) + 1;
+  const lineEnd = autoWorktreeSrc.indexOf("\n", autoPrIdx);
+  const autoPrLine = autoWorktreeSrc.slice(lineStart, lineEnd);
+
+  // The condition should NOT include `&& pushed`
+  assert.ok(
+    !autoPrLine.includes("&& pushed"),
+    "auto_pr condition should not be gated on pushed flag (auto_push dependency)",
+  );
+});
+
+// ─── Bug 2: phases.ts should not duplicate PR creation ──────────────────────
+
+const phasesSrcPath = join(import.meta.dirname, "..", "auto", "phases.ts");
+const phasesSrc = readFileSync(phasesSrcPath, "utf-8");
+
+test("#2302 bug 2: phases.ts should not call createDraftPR (handled by mergeMilestoneToMain)", () => {
+  // After fix, phases.ts should not import or call createDraftPR because
+  // PR creation is handled inside mergeMilestoneToMain in auto-worktree.ts
+  const createDraftPRCalls = phasesSrc.match(/createDraftPR\(/g) || [];
+
+  assert.equal(
+    createDraftPRCalls.length,
+    0,
+    "phases.ts should not call createDraftPR — it's handled by mergeMilestoneToMain",
+  );
+});
+
+// ─── Bug 3: createDraftPR should accept head and base branch parameters ─────
+
+const gitServiceSrcPath = join(import.meta.dirname, "..", "git-service.ts");
+const gitServiceSrc = readFileSync(gitServiceSrcPath, "utf-8");
+
+test("#2302 bug 3: createDraftPR should accept head and base branch parameters", () => {
+  // Find the createDraftPR function signature
+  const fnIdx = gitServiceSrc.indexOf("function createDraftPR");
+  assert.ok(fnIdx !== -1, "createDraftPR function exists");
+
+  // Get the function signature (up to the closing paren)
+  const sigEnd = gitServiceSrc.indexOf(")", fnIdx);
+  const signature = gitServiceSrc.slice(fnIdx, sigEnd);
+
+  // Should have head and base parameters
+  assert.ok(
+    signature.includes("head") || signature.includes("branch"),
+    "createDraftPR should accept a head/branch parameter",
+  );
+});
+
+test("#2302 bug 3: createDraftPR should pass --head and --base to gh pr create", () => {
+  const fnIdx = gitServiceSrc.indexOf("function createDraftPR");
+  const fnEnd = gitServiceSrc.indexOf("\n}", fnIdx);
+  const fnBody = gitServiceSrc.slice(fnIdx, fnEnd);
+
+  assert.ok(
+    fnBody.includes("--head"),
+    "createDraftPR should pass --head to gh pr create",
+  );
+  assert.ok(
+    fnBody.includes("--base"),
+    "createDraftPR should pass --base to gh pr create",
+  );
+});