gsd-pi 2.74.0-dev.2b524c3 → 2.74.0-dev.b741afb

package/src/resources/extensions/gsd/memory-store.ts

@@ -3,7 +3,19 @@
 // Storage layer for auto-learned project memories. Follows context-store.ts patterns.
 // All functions degrade gracefully: return empty results when DB unavailable, never throw.
 
-import { isDbAvailable, _getAdapter, transaction } from './gsd-db.js';
+import {
+  isDbAvailable,
+  _getAdapter,
+  transaction,
+  insertMemoryRow,
+  rewriteMemoryId,
+  updateMemoryContentRow,
+  incrementMemoryHitCount,
+  supersedeMemoryRow,
+  markMemoryUnitProcessed,
+  decayMemoriesBefore,
+  supersedeLowestRankedMemories,
+} from './gsd-db.js';
 
 // ─── Types ──────────────────────────────────────────────────────────────────
 
@@ -170,28 +182,22 @@ export function createMemory(fields: {
     const now = new Date().toISOString();
     // Insert with a temporary placeholder ID — seq is auto-assigned
     const placeholder = `_TMP_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
-    adapter.prepare(
-      `INSERT INTO memories (id, category, content, confidence, source_unit_type, source_unit_id, created_at, updated_at)
-       VALUES (:id, :category, :content, :confidence, :source_unit_type, :source_unit_id, :created_at, :updated_at)`,
-    ).run({
-      ':id': placeholder,
-      ':category': fields.category,
-      ':content': fields.content,
-      ':confidence': fields.confidence ?? 0.8,
-      ':source_unit_type': fields.source_unit_type ?? null,
-      ':source_unit_id': fields.source_unit_id ?? null,
-      ':created_at': now,
-      ':updated_at': now,
+    insertMemoryRow({
+      id: placeholder,
+      category: fields.category,
+      content: fields.content,
+      confidence: fields.confidence ?? 0.8,
+      sourceUnitType: fields.source_unit_type ?? null,
+      sourceUnitId: fields.source_unit_id ?? null,
+      createdAt: now,
+      updatedAt: now,
     });
-    // Derive the real ID from the assigned seq
+    // Derive the real ID from the assigned seq (SELECT is still fine via adapter)
     const row = adapter.prepare('SELECT seq FROM memories WHERE id = :id').get({ ':id': placeholder });
     if (!row) return placeholder; // fallback — should not happen
     const seq = row['seq'] as number;
     const realId = `MEM${String(seq).padStart(3, '0')}`;
-    adapter.prepare('UPDATE memories SET id = :real_id WHERE id = :placeholder').run({
-      ':real_id': realId,
-      ':placeholder': placeholder,
-    });
+    rewriteMemoryId(placeholder, realId);
     return realId;
   } catch {
     return null;
@@ -203,20 +209,9 @@ export function createMemory(fields: {
  */
 export function updateMemoryContent(id: string, content: string, confidence?: number): boolean {
   if (!isDbAvailable()) return false;
-  const adapter = _getAdapter();
-  if (!adapter) return false;
 
   try {
-    const now = new Date().toISOString();
-    if (confidence != null) {
-      adapter.prepare(
-        'UPDATE memories SET content = :content, confidence = :confidence, updated_at = :updated_at WHERE id = :id',
-      ).run({ ':content': content, ':confidence': confidence, ':updated_at': now, ':id': id });
-    } else {
-      adapter.prepare(
-        'UPDATE memories SET content = :content, updated_at = :updated_at WHERE id = :id',
-      ).run({ ':content': content, ':updated_at': now, ':id': id });
-    }
+    updateMemoryContentRow(id, content, confidence, new Date().toISOString());
     return true;
   } catch {
     return false;
@@ -228,13 +223,9 @@ export function updateMemoryContent(id: string, content: string, confidence?: nu
  */
 export function reinforceMemory(id: string): boolean {
   if (!isDbAvailable()) return false;
-  const adapter = _getAdapter();
-  if (!adapter) return false;
 
   try {
-    adapter.prepare(
-      'UPDATE memories SET hit_count = hit_count + 1, updated_at = :updated_at WHERE id = :id',
-    ).run({ ':updated_at': new Date().toISOString(), ':id': id });
+    incrementMemoryHitCount(id, new Date().toISOString());
     return true;
   } catch {
     return false;
@@ -246,13 +237,9 @@ export function reinforceMemory(id: string): boolean {
  */
 export function supersedeMemory(oldId: string, newId: string): boolean {
   if (!isDbAvailable()) return false;
-  const adapter = _getAdapter();
-  if (!adapter) return false;
 
   try {
-    adapter.prepare(
-      'UPDATE memories SET superseded_by = :new_id, updated_at = :updated_at WHERE id = :old_id',
-    ).run({ ':new_id': newId, ':updated_at': new Date().toISOString(), ':old_id': oldId });
+    supersedeMemoryRow(oldId, newId, new Date().toISOString());
     return true;
   } catch {
     return false;
@@ -284,14 +271,9 @@ export function isUnitProcessed(unitKey: string): boolean {
  */
 export function markUnitProcessed(unitKey: string, activityFile: string): boolean {
   if (!isDbAvailable()) return false;
-  const adapter = _getAdapter();
-  if (!adapter) return false;
 
   try {
-    adapter.prepare(
-      `INSERT OR IGNORE INTO memory_processed_units (unit_key, activity_file, processed_at)
-       VALUES (:key, :file, :at)`,
-    ).run({ ':key': unitKey, ':file': activityFile, ':at': new Date().toISOString() });
+    markMemoryUnitProcessed(unitKey, activityFile, new Date().toISOString());
     return true;
   } catch {
     return false;
@@ -310,7 +292,7 @@ export function decayStaleMemories(thresholdUnits = 20): void {
   if (!adapter) return;
 
   try {
-    // Find the timestamp of the Nth most recent processed unit
+    // Find the timestamp of the Nth most recent processed unit (read-only SELECT)
     const row = adapter.prepare(
       `SELECT processed_at FROM memory_processed_units
        ORDER BY processed_at DESC
@@ -320,11 +302,7 @@ export function decayStaleMemories(thresholdUnits = 20): void {
     if (!row) return; // not enough processed units yet
 
     const cutoff = row['processed_at'] as string;
-    adapter.prepare(
-      `UPDATE memories
-       SET confidence = MAX(0.1, confidence - 0.1), updated_at = :now
-       WHERE superseded_by IS NULL AND updated_at < :cutoff AND confidence > 0.1`,
-    ).run({ ':now': new Date().toISOString(), ':cutoff': cutoff });
+    decayMemoriesBefore(cutoff, new Date().toISOString());
   } catch {
     // non-fatal
   }
@@ -346,16 +324,7 @@ export function enforceMemoryCap(max = 50): void {
     if (count <= max) return;
 
     const excess = count - max;
-    // Batch update: supersede lowest-ranked active memories in a single statement
-    adapter.prepare(
-      `UPDATE memories SET superseded_by = 'CAP_EXCEEDED', updated_at = :now
-       WHERE id IN (
-         SELECT id FROM memories
-         WHERE superseded_by IS NULL
-         ORDER BY (confidence * (1.0 + hit_count * 0.1)) ASC
-         LIMIT :limit
-       )`,
-    ).run({ ':now': new Date().toISOString(), ':limit': excess });
+    supersedeLowestRankedMemories(excess, new Date().toISOString());
   } catch {
     // non-fatal
   }

package/src/resources/extensions/gsd/milestone-validation-gates.ts

@@ -11,7 +11,7 @@
  * dispatch rules, and state derivation. See gate-registry.ts.
  */
 
-import { _getAdapter } from "./gsd-db.js";
+import { isDbAvailable, upsertQualityGate } from "./gsd-db.js";
 import { getGatesForTurn } from "./gate-registry.js";
 
 /**
@@ -31,24 +31,23 @@ export function insertMilestoneValidationGates(
   verdict: string,
   evaluatedAt: string,
 ): void {
-  const db = _getAdapter();
-  if (!db) return;
+  if (!isDbAvailable()) return;
 
   const gateVerdict = verdict === "pass" ? "pass" : "flag";
   const milestoneGates = getGatesForTurn("validate-milestone");
 
   for (const def of milestoneGates) {
-    db.prepare(
-      `INSERT OR REPLACE INTO quality_gates
-       (milestone_id, slice_id, gate_id, scope, task_id, status, verdict, rationale, findings, evaluated_at)
-       VALUES (:mid, :sid, :gid, 'milestone', '', 'complete', :verdict, :rationale, '', :evaluated_at)`,
-    ).run({
-      ":mid": milestoneId,
-      ":sid": sliceId,
-      ":gid": def.id,
-      ":verdict": gateVerdict,
-      ":rationale": `${def.promptSection} — milestone validation verdict: ${verdict}`,
-      ":evaluated_at": evaluatedAt,
+    upsertQualityGate({
+      milestoneId,
+      sliceId,
+      gateId: def.id,
+      scope: "milestone",
+      taskId: "",
+      status: "complete",
+      verdict: gateVerdict,
+      rationale: `${def.promptSection} — milestone validation verdict: ${verdict}`,
+      findings: "",
+      evaluatedAt,
     });
   }
 }

package/src/resources/extensions/gsd/native-git-bridge.ts

@@ -323,7 +323,7 @@ export function nativeIsRepo(basePath: string): boolean {
     return native.gitIsRepo(basePath);
   }
   try {
-    execSync("git rev-parse --git-dir", { cwd: basePath, stdio: "pipe" });
+    execFileSync("git", ["rev-parse", "--git-dir"], { cwd: basePath, stdio: "pipe" });
     return true;
   } catch {
     return false;
@@ -790,16 +790,15 @@ export function nativeCommit(
 
   // Fallback: use git commit with stdin pipe for safe multi-line messages
   try {
-    const result = execSync(
-      `git commit --no-verify -F -${options?.allowEmpty ? " --allow-empty" : ""}`,
-      {
-        cwd: basePath,
-        stdio: ["pipe", "pipe", "pipe"],
-        encoding: "utf-8",
-        env: GIT_NO_PROMPT_ENV,
-        input: message,
-      },
-    ).trim();
+    const args = ["commit", "--no-verify", "-F", "-"];
+    if (options?.allowEmpty) args.push("--allow-empty");
+    const result = execFileSync("git", args, {
+      cwd: basePath,
+      stdio: ["pipe", "pipe", "pipe"],
+      encoding: "utf-8",
+      env: GIT_NO_PROMPT_ENV,
+      input: message,
+    }).trim();
     return result;
   } catch (err: unknown) {
     const errObj = err as { stdout?: string; stderr?: string; message?: string };
@@ -940,7 +939,7 @@ export function nativeResetHard(basePath: string): void {
     native.gitResetHard(basePath);
     return;
   }
-  execSync("git reset --hard HEAD", { cwd: basePath, stdio: "pipe" });
+  execFileSync("git", ["reset", "--hard", "HEAD"], { cwd: basePath, stdio: "pipe" });
 }
 
 /**

package/src/resources/extensions/gsd/prompts/add-tests.md

@@ -0,0 +1,35 @@
+You are generating tests for recently completed GSD work.
+
+## Slice: {{sliceId}} — {{sliceTitle}}
+
+### Summary
+
+{{sliceSummary}}
+
+### Existing Test Patterns
+
+{{existingTestPatterns}}
+
+## Working Directory
+
+`{{workingDirectory}}`
+
+## Instructions
+
+1. Read the slice summary above to understand what was built
+2. Identify the source files that were created or modified for this slice
+3. Read the implementation code to understand behavior, edge cases, and error paths
+4. Write comprehensive tests following the project's existing test patterns and framework
+5. Run the tests to verify they pass
+6. Fix any failures
+
+### Rules
+
+- Follow the project's existing test patterns (framework, assertions, file structure)
+- Test behavior, not implementation details
+- Cover: happy path, edge cases, error conditions, boundary values
+- Do NOT modify implementation files — only create or update test files
+- Name test files consistently with the project's conventions
+- Keep tests focused and readable
+
+{{skillActivation}}

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

@@ -345,8 +345,15 @@ function reconcileDiskToDb(basePath: string): MilestoneRow[] {
     const dbSliceIds = new Set(dbSlices.map(s => s.id));
 
     let roadmapContent: string;
-    try { roadmapContent = readFileSync(roadmapPath, "utf-8"); }
-    catch { continue; }
+    try {
+      roadmapContent = readFileSync(roadmapPath, "utf-8");
+    } catch (err) {
+      logWarning("state", "reconcileDiskToDb: roadmap read failed, skipping milestone", {
+        mid,
+        error: (err as Error).message,
+      });
+      continue;
+    }
 
     const parsed = parseRoadmap(roadmapContent);
     for (const s of parsed.slices) {

package/src/resources/extensions/gsd/tests/commands-backlog.test.ts

@@ -0,0 +1,158 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdirSync, writeFileSync, readFileSync, existsSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { randomUUID } from "node:crypto";
+
+// ─── Helpers ──────────────────────────────────────────────────────────────
+
+function makeTmpBase(): string {
+  const base = join(tmpdir(), `gsd-backlog-test-${randomUUID()}`);
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+  return base;
+}
+
+function cleanup(base: string): void {
+  try { rmSync(base, { recursive: true, force: true }); } catch { /* */ }
+}
+
+function backlogPath(base: string): string {
+  return join(base, ".gsd", "BACKLOG.md");
+}
+
+function writeBacklog(base: string, content: string): void {
+  writeFileSync(backlogPath(base), content, "utf-8");
+}
+
+function readBacklog(base: string): string {
+  return readFileSync(backlogPath(base), "utf-8");
+}
+
+// Test the parsing/writing logic inline since the handler requires runtime context
+
+interface BacklogItem {
+  id: string;
+  title: string;
+  done: boolean;
+  note: string;
+}
+
+function parseBacklog(content: string): BacklogItem[] {
+  const items: BacklogItem[] = [];
+  for (const line of content.split("\n")) {
+    const match = line.match(/^- \[([ x])\] (999\.\d+) — (.+?)(?:\s*\((.+)\))?$/);
+    if (match) {
+      items.push({
+        id: match[2],
+        title: match[3].trim(),
+        done: match[1] === "x",
+        note: match[4] ?? "",
+      });
+    }
+  }
+  return items;
+}
+
+function formatBacklog(items: BacklogItem[]): string {
+  const lines = ["# Backlog\n"];
+  for (const item of items) {
+    const check = item.done ? "x" : " ";
+    const note = item.note ? ` (${item.note})` : "";
+    lines.push(`- [${check}] ${item.id} — ${item.title}${note}`);
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+
+// ─── Tests ──────────────────────────────────────────────────────────────
+
+test("backlog: parse empty file returns empty array", () => {
+  const items = parseBacklog("");
+  assert.equal(items.length, 0);
+});
+
+test("backlog: parse valid entries", () => {
+  const content = `# Backlog
+
+- [ ] 999.1 — OAuth support (added 2026-03-23)
+- [x] 999.2 — Rate limiting (promoted 2026-03-24)
+- [ ] 999.3 — Dark mode`;
+
+  const items = parseBacklog(content);
+  assert.equal(items.length, 3);
+  assert.equal(items[0].id, "999.1");
+  assert.equal(items[0].title, "OAuth support");
+  assert.equal(items[0].done, false);
+  assert.equal(items[0].note, "added 2026-03-23");
+
+  assert.equal(items[1].id, "999.2");
+  assert.equal(items[1].done, true);
+  assert.equal(items[1].note, "promoted 2026-03-24");
+
+  assert.equal(items[2].id, "999.3");
+  assert.equal(items[2].title, "Dark mode");
+  assert.equal(items[2].note, "");
+});
+
+test("backlog: format roundtrips correctly", () => {
+  const items: BacklogItem[] = [
+    { id: "999.1", title: "OAuth support", done: false, note: "added 2026-03-23" },
+    { id: "999.2", title: "Rate limiting", done: true, note: "promoted 2026-03-24" },
+  ];
+
+  const formatted = formatBacklog(items);
+  const parsed = parseBacklog(formatted);
+
+  assert.equal(parsed.length, 2);
+  assert.equal(parsed[0].id, "999.1");
+  assert.equal(parsed[0].title, "OAuth support");
+  assert.equal(parsed[1].done, true);
+});
+
+test("backlog: write and read from disk", () => {
+  const base = makeTmpBase();
+  try {
+    const items: BacklogItem[] = [
+      { id: "999.1", title: "Test item", done: false, note: "added 2026-03-23" },
+    ];
+    writeBacklog(base, formatBacklog(items));
+
+    assert.ok(existsSync(backlogPath(base)));
+    const content = readBacklog(base);
+    assert.ok(content.includes("999.1"));
+    assert.ok(content.includes("Test item"));
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("backlog: next ID increments correctly", () => {
+  const items: BacklogItem[] = [
+    { id: "999.1", title: "First", done: false, note: "" },
+    { id: "999.2", title: "Second", done: false, note: "" },
+    { id: "999.5", title: "Fifth", done: false, note: "" },
+  ];
+
+  let maxNum = 0;
+  for (const item of items) {
+    const match = item.id.match(/^999\.(\d+)$/);
+    if (match) {
+      const num = parseInt(match[1], 10);
+      if (num > maxNum) maxNum = num;
+    }
+  }
+  const nextId = `999.${maxNum + 1}`;
+  assert.equal(nextId, "999.6");
+});
+
+test("backlog: empty backlog returns no items", () => {
+  const base = makeTmpBase();
+  try {
+    // No BACKLOG.md exists
+    assert.ok(!existsSync(backlogPath(base)));
+    // Would return empty array
+  } finally {
+    cleanup(base);
+  }
+});

package/src/resources/extensions/gsd/tests/commands-do.test.ts

@@ -0,0 +1,127 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+// ─── Mock dispatcher to capture routed commands ─────────────────────────
+
+let lastRouted: string | null = null;
+let lastQuick: string | null = null;
+
+const mockCtx = {
+  ui: {
+    notify: (_msg: string, _level: string) => {},
+  },
+} as any;
+
+// We test the keyword matching logic directly since the handler imports
+// the dispatcher dynamically (which requires the full extension runtime).
+
+// Inline the route-matching logic from commands-do.ts for unit testing.
+interface Route {
+  keywords: string[];
+  command: string;
+}
+
+const ROUTES: Route[] = [
+  { keywords: ["progress", "status", "dashboard", "how far", "where are we"], command: "status" },
+  { keywords: ["auto", "autonomous", "run all", "keep going", "start auto"], command: "auto" },
+  { keywords: ["stop", "halt", "abort"], command: "stop" },
+  { keywords: ["pause", "break", "take a break"], command: "pause" },
+  { keywords: ["history", "past", "what happened", "previous"], command: "history" },
+  { keywords: ["doctor", "health", "diagnose", "check health"], command: "doctor" },
+  { keywords: ["clean up", "cleanup", "remove old", "prune", "tidy"], command: "cleanup" },
+  { keywords: ["ship", "pull request", "create pr", "open pr", "merge"], command: "ship" },
+  { keywords: ["discuss", "talk about", "architecture", "design"], command: "discuss" },
+  { keywords: ["undo", "revert", "rollback", "take back"], command: "undo" },
+  { keywords: ["skip", "skip task", "skip this"], command: "skip" },
+  { keywords: ["visualize", "viz", "graph", "chart", "show graph"], command: "visualize" },
+  { keywords: ["capture", "note", "idea", "thought", "remember"], command: "capture" },
+  { keywords: ["inspect", "database", "sqlite", "db state"], command: "inspect" },
+  { keywords: ["session report", "session summary", "cost summary", "how much"], command: "session-report" },
+  { keywords: ["backlog", "parking lot", "later", "someday"], command: "backlog" },
+  { keywords: ["add tests", "write tests", "generate tests", "test coverage"], command: "add-tests" },
+  { keywords: ["next", "step", "next step", "what's next"], command: "next" },
+];
+
+interface MatchResult {
+  command: string;
+  remainingArgs: string;
+  score: number;
+}
+
+function matchRoute(input: string): MatchResult | null {
+  const lower = input.toLowerCase();
+  let bestMatch: MatchResult | null = null;
+
+  for (const route of ROUTES) {
+    for (const keyword of route.keywords) {
+      if (lower.includes(keyword)) {
+        const score = keyword.length;
+        if (!bestMatch || score > bestMatch.score) {
+          const idx = lower.indexOf(keyword);
+          const remaining = (input.slice(0, idx) + input.slice(idx + keyword.length)).trim();
+          bestMatch = { command: route.command, remainingArgs: remaining, score };
+        }
+      }
+    }
+  }
+
+  return bestMatch;
+}
+
+// ─── Tests ──────────────────────────────────────────────────────────────
+
+test("/gsd do: routes 'show me progress' to status", () => {
+  const match = matchRoute("show me progress");
+  assert.ok(match);
+  assert.equal(match.command, "status");
+});
+
+test("/gsd do: routes 'run autonomously' to auto", () => {
+  const match = matchRoute("run autonomously");
+  assert.ok(match);
+  assert.equal(match.command, "auto");
+});
+
+test("/gsd do: routes 'clean up old branches' to cleanup", () => {
+  const match = matchRoute("clean up old branches");
+  assert.ok(match);
+  assert.equal(match.command, "cleanup");
+  assert.equal(match.remainingArgs, "old branches");
+});
+
+test("/gsd do: routes 'create pr for milestone' to ship", () => {
+  const match = matchRoute("create pr for milestone");
+  assert.ok(match);
+  assert.equal(match.command, "ship");
+});
+
+test("/gsd do: routes 'add tests for S03' to add-tests", () => {
+  const match = matchRoute("add tests for S03");
+  assert.ok(match);
+  assert.equal(match.command, "add-tests");
+});
+
+test("/gsd do: routes 'what is next' to next", () => {
+  const match = matchRoute("what's next");
+  assert.ok(match);
+  assert.equal(match.command, "next");
+});
+
+test("/gsd do: returns null for unrecognized input", () => {
+  const match = matchRoute("florbinate the gizmo");
+  assert.equal(match, null);
+});
+
+test("/gsd do: prefers longer keyword match", () => {
+  // "check health" (12 chars) should beat "health" (6 chars)
+  const match = matchRoute("check health of the system");
+  assert.ok(match);
+  assert.equal(match.command, "doctor");
+  assert.ok(match.score >= 12);
+});
+
+test("/gsd do: routes 'session report' to session-report", () => {
+  const match = matchRoute("show me the session report");
+  assert.ok(match);
+  assert.equal(match.command, "session-report");
+});

package/src/resources/extensions/gsd/tests/commands-pr-branch.test.ts

@@ -0,0 +1,68 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+// Test the filtering logic used by /gsd pr-branch.
+// Full integration requires git operations, so we test the path filtering.
+
+test("pr-branch: identifies .gsd/ paths", () => {
+  const files = [
+    ".gsd/milestones/M001/ROADMAP.md",
+    ".gsd/metrics.json",
+    "src/main.ts",
+    "package.json",
+    ".planning/PLAN.md",
+    "PLAN.md",
+  ];
+
+  const codeFiles = files.filter(
+    (f) => !f.startsWith(".gsd/") && !f.startsWith(".planning/") && f !== "PLAN.md",
+  );
+
+  assert.deepEqual(codeFiles, ["src/main.ts", "package.json"]);
+});
+
+test("pr-branch: all .gsd/ files returns empty", () => {
+  const files = [
+    ".gsd/milestones/M001/ROADMAP.md",
+    ".gsd/metrics.json",
+    ".gsd/BACKLOG.md",
+  ];
+
+  const codeFiles = files.filter(
+    (f) => !f.startsWith(".gsd/") && !f.startsWith(".planning/") && f !== "PLAN.md",
+  );
+
+  assert.equal(codeFiles.length, 0);
+});
+
+test("pr-branch: mixed commits with code changes", () => {
+  const files = [
+    ".gsd/milestones/M001/ROADMAP.md",
+    "src/auth.ts",
+    "src/auth.test.ts",
+  ];
+
+  const hasCodeChanges = files.some(
+    (f) => !f.startsWith(".gsd/") && !f.startsWith(".planning/") && f !== "PLAN.md",
+  );
+
+  assert.ok(hasCodeChanges);
+});
+
+test("pr-branch: --dry-run flag", () => {
+  assert.ok("--dry-run".includes("--dry-run"));
+  assert.ok(!"--name my-branch".includes("--dry-run"));
+});
+
+test("pr-branch: --name flag parsing", () => {
+  const args = "--name my-clean-pr";
+  const nameMatch = args.match(/--name\s+(\S+)/);
+  assert.ok(nameMatch);
+  assert.equal(nameMatch[1], "my-clean-pr");
+});
+
+test("pr-branch: default branch name", () => {
+  const currentBranch = "feat/add-auth";
+  const prBranch = `pr/${currentBranch}`;
+  assert.equal(prBranch, "pr/feat/add-auth");
+});