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

package/dist/resources/extensions/gsd/commands/handlers/workflow.js

@@ -25,6 +25,61 @@ const WORKFLOW_USAGE = [
     "  pause             — Pause custom workflow auto-mode",
     "  resume            — Resume paused custom workflow auto-mode",
 ].join("\n");
+function splitWorkflowRunArgs(input) {
+    const tokens = [];
+    let current = "";
+    let quote = null;
+    let escapeNext = false;
+    for (const ch of input) {
+        if (escapeNext) {
+            current += ch;
+            escapeNext = false;
+            continue;
+        }
+        if (ch === "\\") {
+            escapeNext = true;
+            continue;
+        }
+        if (quote) {
+            if (ch === quote) {
+                quote = null;
+            }
+            else {
+                current += ch;
+            }
+            continue;
+        }
+        if (ch === '"' || ch === "'") {
+            quote = ch;
+            continue;
+        }
+        if (/\s/.test(ch)) {
+            if (current) {
+                tokens.push(current);
+                current = "";
+            }
+            continue;
+        }
+        current += ch;
+    }
+    if (escapeNext)
+        current += "\\";
+    if (current)
+        tokens.push(current);
+    return tokens;
+}
+export function parseWorkflowRunArgs(args) {
+    const parts = splitWorkflowRunArgs(args);
+    const defName = parts[0] ?? "";
+    const overrides = {};
+    for (let i = 1; i < parts.length; i++) {
+        const eqIdx = parts[i].indexOf("=");
+        if (eqIdx > 0) {
+            overrides[parts[i].slice(0, eqIdx)] = parts[i].slice(eqIdx + 1);
+        }
+    }
+    return { defName, overrides };
+}
 async function handleCustomWorkflow(sub, ctx, pi) {
     // Bare `/gsd workflow` — show usage
     if (!sub) {
@@ -43,15 +98,7 @@ async function handleCustomWorkflow(sub, ctx, pi) {
             ctx.ui.notify("Usage: /gsd workflow run <name> [param=value ...]", "warning");
             return true;
         }
-        const parts = args.split(/\s+/);
-        const defName = parts[0];
-        const overrides = {};
-        for (let i = 1; i < parts.length; i++) {
-            const eqIdx = parts[i].indexOf("=");
-            if (eqIdx > 0) {
-                overrides[parts[i].slice(0, eqIdx)] = parts[i].slice(eqIdx + 1);
-            }
-        }
+        const { defName, overrides } = parseWorkflowRunArgs(args);
         try {
             const base = projectRoot();
             const runDir = createRun(base, defName, Object.keys(overrides).length > 0 ? overrides : undefined);
@@ -146,6 +193,18 @@ async function handleCustomWorkflow(sub, ctx, pi) {
     return true;
 }
 export async function handleWorkflowCommand(trimmed, ctx, pi) {
+    // ── /gsd do — natural language routing (must be early to route to other commands) ──
+    if (trimmed === "do" || trimmed.startsWith("do ")) {
+        const { handleDo } = await import("../../commands-do.js");
+        await handleDo(trimmed.replace(/^do\s*/, "").trim(), ctx, pi);
+        return true;
+    }
+    // ── Backlog management ──
+    if (trimmed === "backlog" || trimmed.startsWith("backlog ")) {
+        const { handleBacklog } = await import("../../commands-backlog.js");
+        await handleBacklog(trimmed.replace(/^backlog\s*/, "").trim(), ctx, pi);
+        return true;
+    }
     // ── Custom workflow commands (`/gsd workflow ...`) ──
     if (trimmed === "workflow" || trimmed.startsWith("workflow ")) {
         const sub = trimmed.slice("workflow".length).trim();

package/dist/resources/extensions/gsd/commands-add-tests.js

@@ -0,0 +1,111 @@
+/**
+ * GSD Command — /gsd add-tests
+ *
+ * Generates tests for a completed slice by dispatching an LLM prompt
+ * with implementation context (summaries, changed files, test patterns).
+ */
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+import { deriveState } from "./state.js";
+import { gsdRoot, resolveSliceFile } from "./paths.js";
+import { loadPrompt } from "./prompt-loader.js";
+function findLastCompletedSlice(basePath, milestoneId) {
+    // Scan disk for slices that have a SUMMARY.md (indicating completion)
+    const slicesDir = join(gsdRoot(basePath), "milestones", milestoneId, "slices");
+    if (!existsSync(slicesDir))
+        return null;
+    try {
+        const entries = readdirSync(slicesDir, { withFileTypes: true })
+            .filter((e) => e.isDirectory() && /^S\d+$/.test(e.name))
+            .sort((a, b) => b.name.localeCompare(a.name)); // reverse order — latest first
+        for (const entry of entries) {
+            const summaryPath = join(slicesDir, entry.name, `${entry.name}-SUMMARY.md`);
+            if (existsSync(summaryPath))
+                return entry.name;
+        }
+    }
+    catch {
+        // non-fatal
+    }
+    return null;
+}
+function readSliceSummary(basePath, milestoneId, sliceId) {
+    const summaryPath = resolveSliceFile(basePath, milestoneId, sliceId, "SUMMARY");
+    if (summaryPath && existsSync(summaryPath)) {
+        const content = readFileSync(summaryPath, "utf-8");
+        const titleMatch = content.match(/^#\s+(.+)/m);
+        return { title: titleMatch?.[1] ?? sliceId, content };
+    }
+    return { title: sliceId, content: "(no summary available)" };
+}
+function detectTestPatterns(basePath) {
+    const patterns = [];
+    // Check for common test configs
+    const checks = [
+        { file: "jest.config.ts", name: "Jest" },
+        { file: "jest.config.js", name: "Jest" },
+        { file: "vitest.config.ts", name: "Vitest" },
+        { file: "vitest.config.js", name: "Vitest" },
+        { file: ".mocharc.yml", name: "Mocha" },
+    ];
+    for (const check of checks) {
+        if (existsSync(join(basePath, check.file))) {
+            patterns.push(`Framework: ${check.name} (${check.file})`);
+        }
+    }
+    // Look for existing test files to infer patterns
+    const testDirs = ["tests", "test", "src/__tests__", "__tests__"];
+    for (const dir of testDirs) {
+        const fullDir = join(basePath, dir);
+        if (existsSync(fullDir)) {
+            try {
+                const files = readdirSync(fullDir).filter((f) => f.endsWith(".test.ts") || f.endsWith(".spec.ts") || f.endsWith(".test.js"));
+                if (files.length > 0) {
+                    patterns.push(`Test directory: ${dir}/ (${files.length} test files)`);
+                    // Read first test file for patterns
+                    const samplePath = join(fullDir, files[0]);
+                    const sample = readFileSync(samplePath, "utf-8").slice(0, 500);
+                    patterns.push(`Sample pattern from ${files[0]}:\n${sample}`);
+                    break;
+                }
+            }
+            catch {
+                // non-fatal
+            }
+        }
+    }
+    return patterns.length > 0 ? patterns.join("\n") : "No test framework detected. Use Node.js built-in test runner.";
+}
+export async function handleAddTests(args, ctx, pi) {
+    const basePath = process.cwd();
+    const state = await deriveState(basePath);
+    if (!state.activeMilestone) {
+        ctx.ui.notify("No active milestone.", "warning");
+        return;
+    }
+    const milestoneId = state.activeMilestone.id;
+    // Determine target
+    const targetId = args.trim() || findLastCompletedSlice(basePath, milestoneId);
+    if (!targetId) {
+        ctx.ui.notify("No completed slices found. Specify a slice ID: /gsd add-tests S03", "warning");
+        return;
+    }
+    // Gather context
+    const summary = readSliceSummary(basePath, milestoneId, targetId);
+    const testPatterns = detectTestPatterns(basePath);
+    ctx.ui.notify(`Generating tests for ${targetId}: "${summary.title}"...`, "info");
+    try {
+        const prompt = loadPrompt("add-tests", {
+            sliceId: targetId,
+            sliceTitle: summary.title,
+            sliceSummary: summary.content,
+            existingTestPatterns: testPatterns,
+            workingDirectory: basePath,
+        });
+        pi.sendMessage({ customType: "gsd-add-tests", content: prompt, display: false }, { triggerTurn: true });
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        ctx.ui.notify(`Failed to dispatch test generation: ${msg}`, "error");
+    }
+}

package/dist/resources/extensions/gsd/commands-backlog.js

@@ -0,0 +1,140 @@
+/**
+ * GSD Command — /gsd backlog
+ *
+ * Structured backlog management with 999.x numbering.
+ * Items stored in .gsd/BACKLOG.md as markdown checklist.
+ * Items can be promoted to active slices via add-slice.
+ */
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { gsdRoot } from "./paths.js";
+function backlogPath(basePath) {
+    return join(gsdRoot(basePath), "BACKLOG.md");
+}
+function parseBacklog(basePath) {
+    const filePath = backlogPath(basePath);
+    if (!existsSync(filePath))
+        return [];
+    const content = readFileSync(filePath, "utf-8");
+    const items = [];
+    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 writeBacklog(basePath, items) {
+    const filePath = backlogPath(basePath);
+    mkdirSync(dirname(filePath), { recursive: true });
+    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(""); // trailing newline
+    writeFileSync(filePath, lines.join("\n"), "utf-8");
+}
+function nextBacklogId(items) {
+    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;
+        }
+    }
+    return `999.${maxNum + 1}`;
+}
+async function listBacklog(basePath, ctx) {
+    const items = parseBacklog(basePath);
+    if (items.length === 0) {
+        ctx.ui.notify("Backlog is empty. Add items with /gsd backlog add <title>", "info");
+        return;
+    }
+    const lines = ["Backlog:\n"];
+    for (const item of items) {
+        const status = item.done ? "✓" : "○";
+        const note = item.note ? ` (${item.note})` : "";
+        lines.push(`  ${status} ${item.id} — ${item.title}${note}`);
+    }
+    const pending = items.filter((i) => !i.done).length;
+    lines.push(`\n${pending} pending, ${items.length - pending} promoted/done`);
+    ctx.ui.notify(lines.join("\n"), "info");
+}
+async function addBacklogItem(basePath, title, ctx) {
+    if (!title) {
+        ctx.ui.notify("Usage: /gsd backlog add <title>", "warning");
+        return;
+    }
+    const items = parseBacklog(basePath);
+    const id = nextBacklogId(items);
+    const date = new Date().toISOString().slice(0, 10);
+    items.push({ id, title: title.replace(/^['"]|['"]$/g, ""), done: false, note: `added ${date}` });
+    writeBacklog(basePath, items);
+    ctx.ui.notify(`Added ${id}: "${title}"`, "success");
+}
+async function promoteBacklogItem(basePath, itemId, ctx, pi) {
+    if (!itemId) {
+        ctx.ui.notify("Usage: /gsd backlog promote <id>\nExample: /gsd backlog promote 999.1", "warning");
+        return;
+    }
+    const items = parseBacklog(basePath);
+    const item = items.find((i) => i.id === itemId);
+    if (!item) {
+        ctx.ui.notify(`Backlog item ${itemId} not found.`, "warning");
+        return;
+    }
+    if (item.done) {
+        ctx.ui.notify(`${itemId} is already promoted/done.`, "info");
+        return;
+    }
+    // Promote — currently requires single-writer engine (not yet available)
+    // Mark as promoted in backlog for now; slice creation will be available with the engine.
+    item.done = true;
+    item.note = `promoted ${new Date().toISOString().slice(0, 10)}`;
+    writeBacklog(basePath, items);
+    ctx.ui.notify(`Promoted ${itemId}: "${item.title}" — add it to the roadmap manually or wait for engine slice commands.`, "info");
+}
+async function removeBacklogItem(basePath, itemId, ctx) {
+    if (!itemId) {
+        ctx.ui.notify("Usage: /gsd backlog remove <id>", "warning");
+        return;
+    }
+    const items = parseBacklog(basePath);
+    const idx = items.findIndex((i) => i.id === itemId);
+    if (idx === -1) {
+        ctx.ui.notify(`Backlog item ${itemId} not found.`, "warning");
+        return;
+    }
+    const removed = items.splice(idx, 1)[0];
+    writeBacklog(basePath, items);
+    ctx.ui.notify(`Removed ${removed.id}: "${removed.title}"`, "success");
+}
+export async function handleBacklog(args, ctx, pi) {
+    const basePath = process.cwd();
+    const parts = args.trim().split(/\s+/);
+    const sub = parts[0] ?? "";
+    const rest = parts.slice(1).join(" ");
+    switch (sub) {
+        case "":
+            return listBacklog(basePath, ctx);
+        case "add":
+            return addBacklogItem(basePath, rest, ctx);
+        case "promote":
+            return promoteBacklogItem(basePath, rest.trim(), ctx, pi);
+        case "remove":
+            return removeBacklogItem(basePath, rest.trim(), ctx);
+        default:
+            // Treat as implicit add
+            return addBacklogItem(basePath, args, ctx);
+    }
+}

package/dist/resources/extensions/gsd/commands-do.js

@@ -0,0 +1,79 @@
+/**
+ * GSD Command — /gsd do
+ *
+ * Routes freeform natural language to the correct /gsd subcommand
+ * using keyword matching. Falls back to /gsd quick for task-like input.
+ */
+const ROUTES = [
+    { 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: ["export", "report", "share results"], command: "export" },
+    { 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: ["queue", "reorder", "milestone order", "order milestones"], command: "queue" },
+    { 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: ["knowledge", "rule", "pattern", "lesson"], command: "knowledge" },
+    { keywords: ["session report", "session summary", "cost summary", "how much"], command: "session-report" },
+    { keywords: ["backlog", "parking lot", "later", "someday"], command: "backlog" },
+    { keywords: ["pr branch", "clean branch", "filter commits"], command: "pr-branch" },
+    { keywords: ["add tests", "write tests", "generate tests", "test coverage"], command: "add-tests" },
+    { keywords: ["next", "step", "next step", "what's next"], command: "next" },
+    { keywords: ["migrate", "migration", "convert", "upgrade"], command: "migrate" },
+    { keywords: ["steer", "change direction", "pivot", "redirect"], command: "steer" },
+    { keywords: ["park", "shelve", "set aside"], command: "park" },
+    { keywords: ["widget", "toggle widget"], command: "widget" },
+    { keywords: ["logs", "debug logs", "log files"], command: "logs" },
+];
+function matchRoute(input) {
+    const lower = input.toLowerCase();
+    let bestMatch = null;
+    for (const route of ROUTES) {
+        for (const keyword of route.keywords) {
+            if (lower.includes(keyword)) {
+                const score = keyword.length; // Longer match = higher confidence
+                if (!bestMatch || score > bestMatch.score) {
+                    // Strip the matched keyword from input to get remaining args
+                    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;
+}
+export async function handleDo(args, ctx, pi) {
+    if (!args.trim()) {
+        ctx.ui.notify("Usage: /gsd do <what you want to do>\n\n" +
+            "Examples:\n" +
+            "  /gsd do show me progress\n" +
+            "  /gsd do run autonomously\n" +
+            "  /gsd do clean up old branches\n" +
+            "  /gsd do fix the login bug", "warning");
+        return;
+    }
+    const match = matchRoute(args);
+    if (match) {
+        const fullCommand = match.remainingArgs
+            ? `${match.command} ${match.remainingArgs}`
+            : match.command;
+        ctx.ui.notify(`→ /gsd ${fullCommand}`, "info");
+        // Re-dispatch through the main dispatcher
+        const { handleGSDCommand } = await import("./commands/dispatcher.js");
+        await handleGSDCommand(fullCommand, ctx, pi);
+        return;
+    }
+    // No keyword match → treat as quick task
+    ctx.ui.notify(`→ /gsd quick ${args}`, "info");
+    const { handleQuick } = await import("./quick.js");
+    await handleQuick(args, ctx, pi);
+}

package/dist/resources/extensions/gsd/commands-maintenance.js

@@ -449,7 +449,7 @@ export async function handleCleanupProjects(args, ctx) {
  * Prints counts of recovered items and the resulting project phase.
  */
 export async function handleRecover(ctx, basePath) {
-    const { isDbAvailable: dbAvailable, _getAdapter, transaction: dbTransaction } = await import("./gsd-db.js");
+    const { isDbAvailable: dbAvailable, clearEngineHierarchy, transaction: dbTransaction } = await import("./gsd-db.js");
     const { migrateHierarchyToDb } = await import("./md-importer.js");
     const { invalidateStateCache } = await import("./state.js");
     if (!dbAvailable()) {
@@ -457,12 +457,12 @@ export async function handleRecover(ctx, basePath) {
         return;
     }
     try {
-        // 1. Delete + re-populate inside a single transaction for atomicity
-        const db = _getAdapter();
+        // 1. Delete + re-populate inside a single transaction for atomicity.
+        //    clearEngineHierarchy() uses transaction() internally but transaction()
+        //    is re-entrant, so wrapping in dbTransaction() keeps the whole
+        //    clear+repopulate atomic.
         const counts = dbTransaction(() => {
-            db.exec("DELETE FROM tasks");
-            db.exec("DELETE FROM slices");
-            db.exec("DELETE FROM milestones");
+            clearEngineHierarchy();
             return migrateHierarchyToDb(basePath);
         });
         // 3. Invalidate state cache so deriveState() picks up fresh DB data

package/dist/resources/extensions/gsd/commands-pr-branch.js

@@ -0,0 +1,180 @@
+/**
+ * GSD Command — /gsd pr-branch
+ *
+ * Creates a clean PR branch by cherry-picking commits while stripping
+ * any changes to .gsd/, .planning/, and PLAN.md paths. Useful for
+ * upstream PRs where planning artifacts should not be included.
+ */
+import { execFileSync } from "node:child_process";
+import { nativeGetCurrentBranch, nativeDetectMainBranch, nativeBranchExists, } from "./native-git-bridge.js";
+const EXCLUDED_PATHS = [".gsd", ".planning", "PLAN.md"];
+function git(basePath, args) {
+    return execFileSync("git", args, { cwd: basePath, encoding: "utf-8" }).trim();
+}
+function gitAllowFail(basePath, args) {
+    try {
+        execFileSync("git", args, { cwd: basePath, encoding: "utf-8", stdio: "pipe" });
+    }
+    catch {
+        // ignored — caller opts into non-fatal behavior
+    }
+}
+function hasStagedChanges(basePath) {
+    try {
+        execFileSync("git", ["diff", "--cached", "--quiet"], {
+            cwd: basePath,
+            stdio: "pipe",
+        });
+        return false;
+    }
+    catch {
+        return true;
+    }
+}
+function isValidBranchName(name) {
+    try {
+        execFileSync("git", ["check-ref-format", "--branch", name], { stdio: "pipe" });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function getCodeOnlyCommits(basePath, base, head) {
+    try {
+        const allCommits = git(basePath, ["log", "--format=%H", `${base}..${head}`])
+            .split("\n")
+            .filter(Boolean);
+        const codeCommits = [];
+        for (const sha of allCommits) {
+            const files = git(basePath, ["diff-tree", "--no-commit-id", "--name-only", "-r", sha])
+                .split("\n")
+                .filter(Boolean);
+            const hasCodeChanges = files.some((f) => !f.startsWith(".gsd/") && !f.startsWith(".planning/") && f !== "PLAN.md");
+            if (hasCodeChanges) {
+                codeCommits.push(sha);
+            }
+        }
+        return codeCommits.reverse(); // chronological for cherry-picking
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Cherry-pick a commit while stripping excluded paths from the resulting
+ * commit. Returns true if a commit was produced, false if nothing remained
+ * after filtering.
+ */
+function cherryPickFiltered(basePath, sha) {
+    git(basePath, ["cherry-pick", "--no-commit", "--allow-empty", sha]);
+    // Unstage any excluded paths introduced by the cherry-pick.
+    gitAllowFail(basePath, ["reset", "HEAD", "--", ...EXCLUDED_PATHS]);
+    // Restore worktree state for excluded paths from HEAD (if tracked),
+    // then remove any newly introduced untracked files under those paths.
+    gitAllowFail(basePath, ["checkout", "HEAD", "--", ...EXCLUDED_PATHS]);
+    gitAllowFail(basePath, ["clean", "-fdq", "--", ...EXCLUDED_PATHS]);
+    if (!hasStagedChanges(basePath)) {
+        // Nothing remained after filtering — discard worktree residue and skip.
+        git(basePath, ["reset", "--hard", "HEAD"]);
+        return false;
+    }
+    git(basePath, ["commit", "-C", sha]);
+    return true;
+}
+function assertNoExcludedPaths(basePath, base) {
+    const files = git(basePath, [
+        "diff",
+        "--name-only",
+        `${base}..HEAD`,
+    ])
+        .split("\n")
+        .filter(Boolean);
+    const leaked = files.filter((f) => f.startsWith(".gsd/") || f.startsWith(".planning/") || f === "PLAN.md");
+    if (leaked.length > 0) {
+        throw new Error(`PR branch still contains excluded paths: ${leaked.slice(0, 5).join(", ")}${leaked.length > 5 ? ` (+${leaked.length - 5} more)` : ""}`);
+    }
+}
+export async function handlePrBranch(args, ctx) {
+    const basePath = process.cwd();
+    const dryRun = args.includes("--dry-run");
+    const nameMatch = args.match(/--name\s+(\S+)/);
+    const currentBranch = nativeGetCurrentBranch(basePath);
+    const mainBranch = nativeDetectMainBranch(basePath);
+    // Determine base ref (prefer upstream/main if available)
+    let baseRef;
+    try {
+        git(basePath, ["rev-parse", "--verify", "upstream/main"]);
+        baseRef = "upstream/main";
+    }
+    catch {
+        baseRef = mainBranch;
+    }
+    // Find commits with code changes
+    const commits = getCodeOnlyCommits(basePath, baseRef, "HEAD");
+    if (commits.length === 0) {
+        ctx.ui.notify("No code-only commits found (all commits only touch .gsd/ files).", "info");
+        return;
+    }
+    if (dryRun) {
+        const lines = [`Would create PR branch with ${commits.length} commits (filtering .gsd/ paths):\n`];
+        for (const sha of commits) {
+            const msg = git(basePath, ["log", "--format=%s", "-1", sha]);
+            lines.push(`  ${sha.slice(0, 8)} ${msg}`);
+        }
+        ctx.ui.notify(lines.join("\n"), "info");
+        return;
+    }
+    const requestedName = nameMatch?.[1];
+    if (requestedName && !isValidBranchName(requestedName)) {
+        ctx.ui.notify(`Invalid branch name: ${requestedName}. Must satisfy git check-ref-format.`, "error");
+        return;
+    }
+    const defaultName = `pr/${currentBranch}`;
+    const prBranch = requestedName ?? defaultName;
+    if (!isValidBranchName(prBranch)) {
+        ctx.ui.notify(`Derived branch name is invalid: ${prBranch}. Use --name to override.`, "error");
+        return;
+    }
+    if (nativeBranchExists(basePath, prBranch)) {
+        ctx.ui.notify(`Branch ${prBranch} already exists. Use --name to specify a different name, or delete it first.`, "warning");
+        return;
+    }
+    try {
+        // Create clean branch from base
+        git(basePath, ["checkout", "-b", prBranch, baseRef]);
+        // Cherry-pick with path filter
+        let picked = 0;
+        let skipped = 0;
+        for (const sha of commits) {
+            try {
+                if (cherryPickFiltered(basePath, sha)) {
+                    picked++;
+                }
+                else {
+                    skipped++;
+                }
+            }
+            catch (pickErr) {
+                gitAllowFail(basePath, ["cherry-pick", "--abort"]);
+                gitAllowFail(basePath, ["reset", "--hard", "HEAD"]);
+                const detail = pickErr instanceof Error ? pickErr.message : String(pickErr);
+                ctx.ui.notify(`Cherry-pick conflict at ${sha.slice(0, 8)}. Picked ${picked}/${commits.length} commits. Resolve manually.\n${detail}`, "warning");
+                git(basePath, ["checkout", currentBranch]);
+                return;
+            }
+        }
+        // Post-condition: no excluded paths should appear in the PR branch diff.
+        assertNoExcludedPaths(basePath, baseRef);
+        const skippedMsg = skipped > 0 ? ` (${skipped} skipped — contained only planning artifacts)` : "";
+        ctx.ui.notify(`Created ${prBranch} with ${picked} commits${skippedMsg} (no .gsd/ artifacts).\nSwitch back: git checkout ${currentBranch}`, "success");
+    }
+    catch (err) {
+        // Restore original branch on failure
+        gitAllowFail(basePath, ["cherry-pick", "--abort"]);
+        gitAllowFail(basePath, ["reset", "--hard", "HEAD"]);
+        gitAllowFail(basePath, ["checkout", currentBranch]);
+        const msg = err instanceof Error ? err.message : String(err);
+        ctx.ui.notify(`Failed to create PR branch: ${msg}`, "error");
+    }
+}