stonecut 1.4.1 → 1.5.0

package/README.md

@@ -32,7 +32,7 @@ For projects using GitHub issues, we recommend tracking ideas with a `roadmap` l
 ### Prerequisites
 
 - [Bun](https://bun.sh/) — install with `curl -fsSL https://bun.sh/install | bash`
-- An agentic coding CLI — [Claude Code](https://docs.anthropic.com/en/docs/claude-code) (`claude`) is the default runner and must be in your PATH. [OpenAI Codex CLI](https://github.com/openai/codex) (`codex`) is required only when using `--runner codex`.
+- An agentic coding CLI — [Claude Code](https://docs.anthropic.com/en/docs/claude-code) (`claude`) is the default agent and must be in your PATH. [OpenAI Codex CLI](https://github.com/openai/codex) (`codex`) is required only when using `--agent codex`.
 - [GitHub CLI](https://cli.github.com/) — `gh`, authenticated. Required for importing from GitHub (`stonecut import --github`), syncing issue completion back to GitHub, and for pushing branches / creating PRs.
 
 ### Install from npm
@@ -88,22 +88,33 @@ Stonecut uses a local-first execution model: `stonecut run` always reads from `.
 When flags are omitted, Stonecut prompts for each missing parameter:
 
 ```sh
-# Full wizard — prompted for PRD, iterations, branch, and base branch
+# Full wizard — prompted for PRD, branch, base branch, PR mode, agent, iterations
 stonecut
 
-# Partial — only iterations, branch, and base are prompted
+# Partial — skip PRD selection
 stonecut --local my-feature
 
-# Partial — only PRD selection, branch, and base are prompted
-stonecut -i all
+# Partial — skip branch and base branch prompts
+stonecut --branch feat/my-feature --base-branch main
+
+# Partial — skip agent and iterations prompts
+stonecut --agent claude -i all
+
+# Draft PR mode
+stonecut --draft
+
+# Override a stored draft preference back to ready
+stonecut --ready
 ```
 
 You can also use `stonecut run` explicitly — it's identical to bare `stonecut`.
 
-The wizard scans `.stonecut/specs/*/` for local PRDs and presents them with completion counts (e.g. "my-feature (3/7 done)"). An "Import from GitHub" option is always available at the bottom of the list for importing PRDs inline.
+The wizard scans `.stonecut/specs/*/` for local PRDs and presents them with completion counts (e.g. "my-feature (3/7 done)"). Completed PRDs (all issues done) and empty PRDs (no issues) are automatically hidden. An "Import from GitHub" option is always available at the bottom of the list for importing PRDs inline.
 
 Flags provided via CLI skip the corresponding prompts. When all flags are given, the command runs without any prompts.
 
+**Persistence across runs:** The wizard remembers your branch name, base branch, and PR mode (draft/ready) in `status.json` per PRD. On subsequent runs, stored values are used silently — no prompt is shown. CLI flags override stored values when provided. Agent and iterations are intentionally per-run decisions and are always prompted when not provided via flags.
+
 If no `.stonecut/` directory exists, the wizard prints a hint suggesting `stonecut init`.
 
 ### `stonecut init` — Project setup
@@ -127,7 +138,7 @@ The command errors if `config.json` already exists, preventing accidental overwr
 
 ```json
 {
-  "runner": "claude",
+  "agent": "claude",
   "baseBranch": "main",
   "branchPrefix": "stonecut/"
 }
@@ -135,7 +146,7 @@ The command errors if `config.json` already exists, preventing accidental overwr
 
 | Field          | Default       | Description                                                                     |
 | -------------- | ------------- | ------------------------------------------------------------------------------- |
-| `runner`       | `"claude"`    | Agentic CLI runner (`claude`, `codex`). Used when `--runner` is omitted.        |
+| `agent`        | `"claude"`    | Agentic CLI agent (`claude`, `codex`). Used when `--agent` is omitted.          |
 | `baseBranch`   | `"main"`      | Default PR target branch. Suggested in the wizard's base branch prompt.         |
 | `branchPrefix` | `"stonecut/"` | Prefix for suggested branch names (e.g. `feat/stonecut/` for team conventions). |
 
@@ -198,7 +209,7 @@ Or use the interactive wizard, which offers inline GitHub import:
 stonecut
 # → Select "Import from GitHub"
 # → Pick a PRD from the list (filtered by `prd` label)
-# → Continue with iterations, branch, and base branch prompts
+# → Continue with branch, base branch, PR mode, agent, and iterations prompts
 ```
 
 When issues imported from GitHub are completed, Stonecut automatically closes the corresponding GitHub issues. When all issues are done, the parent PRD issue is closed as well.
@@ -218,11 +229,15 @@ When issues imported from GitHub are completed, Stonecut automatically closes th
 
 **`run` flags:**
 
-| Flag           | Short | Required | Description                                                              |
-| -------------- | ----- | -------- | ------------------------------------------------------------------------ |
-| `--local`      | —     | No       | Local PRD name (`.stonecut/specs/<name>/`). Prompted if omitted.         |
-| `--iterations` | `-i`  | No       | Positive integer or `all`. Prompted with default `all` if omitted.       |
-| `--runner`     | —     | No       | Agentic CLI runner (`claude`, `codex`). Default from config or `claude`. |
+| Flag            | Short | Required | Description                                                                   |
+| --------------- | ----- | -------- | ----------------------------------------------------------------------------- |
+| `--local`       | —     | No       | Local PRD name (`.stonecut/specs/<name>/`). Prompted if omitted.              |
+| `--iterations`  | `-i`  | No       | Positive integer or `all`. Prompted with default `all` if omitted.            |
+| `--branch`      | —     | No       | Branch name for the run. Persisted per PRD. Prompted if omitted on first run. |
+| `--base-branch` | —     | No       | Base branch / PR target. Persisted per PRD. Prompted if omitted on first run. |
+| `--agent`       | —     | No       | Agentic CLI agent (`claude`, `codex`). Default from config or `claude`.       |
+| `--draft`       | —     | No       | Create PR as draft.                                                           |
+| `--ready`       | —     | No       | Create PR as ready for review (overrides stored draft preference).            |
 
 **`import` flags:**
 
@@ -242,19 +257,28 @@ When issues imported from GitHub are completed, Stonecut automatically closes th
 
 ### Pre-execution prompts
 
-Before starting, Stonecut prompts for any missing parameters in order:
+Before starting, Stonecut prompts for any missing parameters. Persistent decisions are asked first and remembered across runs; per-run decisions are asked last.
 
-1. **PRD** — select from local PRDs or import from GitHub (skipped when `--local` provided)
-2. **Iterations** — number of issues to process, default `all` (skipped when `-i` provided)
-3. **Branch name** — suggests `<branchPrefix><slug>` based on the spec name (prefix from config or `stonecut/`)
-4. **Base branch** — suggests the configured `baseBranch` or the repository's default branch (usually `main`)
-5. Creates or checks out the branch
+1. **PRD** — Select from local PRDs or import from GitHub. Completed PRDs and PRDs with no issues are hidden. Skipped when `--local` is provided.
+2. **Branch** — If you're on a non-default branch, offers to use the current branch or create a new one. If on the default branch (main/master), prompts for a branch name with a suggested default (`<branchPrefix><slug>`). **Persisted per PRD.** Skipped on subsequent runs or when `--branch` is provided.
+3. **Base branch** — Smart select with contextual defaults based on your branch choice:
+   - Created a new branch from a non-default branch → defaults to the current branch (enables PR chaining / stacked PRs)
+   - Created a new branch from the default branch → defaults to the repo default (main)
+   - Using the current branch → defaults to the repo default (main)
+   - An "Enter a different branch" option is always available. **Persisted per PRD.** Skipped on subsequent runs or when `--base-branch` is provided.
+4. **PR mode** — "Should the PR be opened as a draft?" (y/N). Default: ready. **Persisted per PRD.** Skipped on subsequent runs, or when `--draft` / `--ready` is provided.
+5. **Agent** — "Which agent should execute the issues?" Select from available agents. Default: config value or `claude`. **Not persisted** — asked each run unless `--agent` is provided.
+6. **Iterations** — "How many issues should I tackle this run?" Default: `all`. **Not persisted** — asked each run unless `-i` is provided.
+
+After prompts complete, the branch is created or checked out and execution begins.
 
 When all parameters are provided via flags, no prompts appear and the command runs non-interactively.
 
 ### After a run
 
-Stonecut automatically pushes the branch, creates a PR, and includes a Stonecut Report listing each issue with its status (completed or failed with error reason). The report also shows which runner was used. Timing stats are printed per iteration and for the full session.
+Stonecut automatically pushes the branch and creates a PR (or draft PR, depending on your PR mode preference) with a Stonecut Report listing each issue with its status (completed or failed with error reason). The report also shows which agent was used. Timing stats are printed per iteration and for the full session.
+
+The PR URL is printed to the terminal after creation so you can navigate to it directly.
 
 For imported PRDs, the PR body includes a `Closes #<number>` reference to the parent GitHub issue when all issues are complete.
 
@@ -269,10 +293,23 @@ All execution reads from `.stonecut/specs/<name>/` directories with this structu
 │   ├── 01-setup.md     # Issue files, numbered for ordering
 │   ├── 02-core.md
 │   └── 03-api.md
-├── status.json         # Auto-created: tracks completed issues (gitignored)
+├── status.json         # Auto-created: tracks completion and wizard state (gitignored)
 └── progress.txt        # Auto-created: timestamped completion log (gitignored)
 ```
 
+`status.json` stores both issue completion and persistent wizard decisions:
+
+```json
+{
+  "completed": [1, 2, 3],
+  "branch": "stonecut/my-feature",
+  "baseBranch": "main",
+  "prMode": "ready"
+}
+```
+
+The `branch`, `baseBranch`, and `prMode` fields are written after the wizard completes on first run. On subsequent runs, stored values are used silently. Old status files missing these fields are handled gracefully — the wizard prompts as if it's the first run.
+
 PRDs and issues are committed to git; runtime state (`status.json`, `progress.txt`, `logs/`) is gitignored by the `.stonecut/.gitignore` created during `stonecut init`.
 
 ### Frontmatter

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "stonecut",
-  "version": "1.4.1",
+  "version": "1.5.0",
   "description": "CLI that drives PRD-driven development with agentic coding CLIs",
   "license": "MIT",
   "repository": {

package/src/cli.ts

@@ -11,15 +11,17 @@
 import * as clack from "@clack/prompts";
 import { Command, InvalidArgumentError } from "commander";
 import { createRequire } from "module";
-import { defaultBranch, ensureCleanTree } from "./git";
+import { currentBranch, defaultBranch, ensureCleanTree } from "./git";
 import { slugifyBranchComponent } from "./naming";
 import { setupSkills, removeSkills } from "./skills";
 import { init } from "./init";
 import { importSpec } from "./import";
 import { loadConfig } from "./config";
+import { getWizardState, setWizardState } from "./local";
 import { existsSync } from "fs";
 import { promptForPrd } from "./prd";
 import { executeLocal } from "./execute";
+import { availableRunners } from "./runners/index";
 
 const require = createRequire(import.meta.url);
 const { version } = require("../package.json");
@@ -85,7 +87,9 @@ export function buildProgram(): Command {
 		.option("-i, --iterations <value>", "Number of issues to process, or 'all'")
 		.option("--branch <name>", "Branch name for the run")
 		.option("--base-branch <name>", "Base branch / PR target")
-		.option("--runner <name>", "Agentic CLI runner (claude, codex)")
+		.option("--agent <name>", "Agentic CLI to execute issues (claude, codex)")
+		.option("--draft", "Create PR as draft")
+		.option("--ready", "Create PR as ready for review (overrides stored draft preference)")
 		.action(async (opts) => {
 			ensureCleanTree();
 			const config = loadConfig();
@@ -98,13 +102,168 @@ export function buildProgram(): Command {
 				source = await promptForPrd();
 			}
 
+			// ---- Branch (persistent, immediately after PRD selection) ----
+			const wizardState = getWizardState(source.name);
+			const repoDefault = defaultBranch();
+			const current = currentBranch();
+
+			let branch: string;
+			let needsBranchPrompt = false;
+			// Track how the branch was chosen so the base branch prompt can offer smart defaults.
+			let branchContext:
+				| "used_current"
+				| "created_new_from_non_default"
+				| "created_new_from_default"
+				| "no_context" = "no_context";
+
+			if (opts.branch) {
+				branch = opts.branch;
+			} else if (wizardState.branch) {
+				branch = wizardState.branch;
+			} else {
+				needsBranchPrompt = true;
+				const branchPrefix = config?.branchPrefix ?? "stonecut/";
+				const suggestedBranch = `${branchPrefix}${slugifyBranchComponent(source.name) || "spec"}`;
+
+				if (current && current !== repoDefault) {
+					const choice = await clack.select({
+						message: "What branch should I work on?",
+						options: [
+							{ value: "__use_current__", label: `Use current branch (${current})` },
+							{ value: "__create_new__", label: "Create a new branch" },
+						],
+					});
+					if (clack.isCancel(choice)) throw new Error("Cancelled.");
+
+					if (choice === "__use_current__") {
+						branch = current;
+						branchContext = "used_current";
+					} else {
+						const branchInput = await clack.text({
+							message: "What branch should I work on?",
+							defaultValue: suggestedBranch,
+							placeholder: suggestedBranch,
+						});
+						if (clack.isCancel(branchInput)) throw new Error("Cancelled.");
+						branch = branchInput;
+						branchContext = "created_new_from_non_default";
+					}
+				} else {
+					const branchInput = await clack.text({
+						message: "What branch should I work on?",
+						defaultValue: suggestedBranch,
+						placeholder: suggestedBranch,
+					});
+					if (clack.isCancel(branchInput)) throw new Error("Cancelled.");
+					branch = branchInput;
+					branchContext = "created_new_from_default";
+				}
+			}
+
+			// ---- Base branch (persistent, smart prompt) ----
+			let baseBranch: string;
+			let needsBaseBranchPrompt = false;
+			if (opts.baseBranch) {
+				baseBranch = opts.baseBranch;
+			} else if (wizardState.baseBranch) {
+				baseBranch = wizardState.baseBranch;
+			} else {
+				needsBaseBranchPrompt = true;
+				const configBaseBranch = config?.baseBranch ?? repoDefault;
+
+				if (branchContext === "created_new_from_non_default") {
+					// Creating a new branch from a non-default branch: default to current (for PR chaining)
+					const options: Array<{ value: string; label: string }> = [
+						{ value: current!, label: `${current} (current branch)` },
+					];
+					if (configBaseBranch !== current) {
+						options.push({ value: configBaseBranch, label: `${configBaseBranch} (repo default)` });
+					}
+					options.push({ value: "__enter_different__", label: "Enter a different branch" });
+
+					const choice = await clack.select({
+						message: "What branch should the PR target?",
+						options,
+					});
+					if (clack.isCancel(choice)) throw new Error("Cancelled.");
+
+					if (choice === "__enter_different__") {
+						const input = await clack.text({ message: "What branch should the PR target?" });
+						if (clack.isCancel(input)) throw new Error("Cancelled.");
+						baseBranch = input;
+					} else {
+						baseBranch = choice;
+					}
+				} else {
+					// Using current branch, created from default, or no context: default to repo default
+					const choice = await clack.select({
+						message: "What branch should the PR target?",
+						options: [
+							{ value: configBaseBranch, label: `${configBaseBranch} (repo default)` },
+							{ value: "__enter_different__", label: "Enter a different branch" },
+						],
+					});
+					if (clack.isCancel(choice)) throw new Error("Cancelled.");
+
+					if (choice === "__enter_different__") {
+						const input = await clack.text({ message: "What branch should the PR target?" });
+						if (clack.isCancel(input)) throw new Error("Cancelled.");
+						baseBranch = input;
+					} else {
+						baseBranch = choice;
+					}
+				}
+			}
+
+			// ---- PR mode (persistent) ----
+			let draft: boolean;
+			let needsPrModePrompt = false;
+			if (opts.draft) {
+				draft = true;
+			} else if (opts.ready) {
+				draft = false;
+			} else if (wizardState.prMode !== undefined) {
+				draft = wizardState.prMode === "draft";
+			} else {
+				needsPrModePrompt = true;
+				const shouldDraft = await clack.confirm({
+					message: "Should the PR be opened as a draft?",
+					initialValue: false,
+				});
+				if (clack.isCancel(shouldDraft)) throw new Error("Cancelled.");
+				draft = shouldDraft;
+			}
+
+			// ---- Agent (per-run) ----
+			let runnerName: string;
+			let needsAgentPrompt = false;
+			if (opts.agent) {
+				runnerName = opts.agent;
+			} else {
+				const configAgent = config?.agent ?? config?.runner ?? "claude";
+				const agents = availableRunners();
+				if (agents.length > 1) {
+					needsAgentPrompt = true;
+					const agentChoice = await clack.select({
+						message: "Which agent should execute the issues?",
+						options: agents.map((a) => ({ value: a, label: a })),
+						initialValue: configAgent,
+					});
+					if (clack.isCancel(agentChoice)) throw new Error("Cancelled.");
+					runnerName = agentChoice;
+				} else {
+					runnerName = configAgent;
+				}
+			}
+
+			// ---- Iterations (per-run) ----
 			let iterations: number | "all";
 			const needsIterationPrompt = opts.iterations === undefined;
 			if (!needsIterationPrompt) {
 				iterations = parseIterations(opts.iterations);
 			} else {
 				const iterationsInput = await clack.text({
-					message: "Iterations:",
+					message: "How many issues should I tackle this run?",
 					defaultValue: "all",
 					placeholder: "all",
 					validate: (value) => {
@@ -121,46 +280,22 @@ export function buildProgram(): Command {
 				iterations = parseIterations(iterationsInput);
 			}
 
-			const isWizard = validated.kind === "prompt" || needsIterationPrompt;
+			const isWizard =
+				validated.kind === "prompt" ||
+				needsIterationPrompt ||
+				needsBranchPrompt ||
+				needsBaseBranchPrompt ||
+				needsPrModePrompt ||
+				needsAgentPrompt;
 			if (isWizard && !existsSync(".stonecut")) {
 				console.log("Hint: run `stonecut init` to set up project config and gitignore.\n");
 			}
 
-			let branch: string;
-			if (opts.branch) {
-				branch = opts.branch;
-			} else {
-				const branchPrefix = config?.branchPrefix ?? "stonecut/";
-				const suggestedBranch = `${branchPrefix}${slugifyBranchComponent(source.name) || "spec"}`;
-				const branchInput = await clack.text({
-					message: "Branch name:",
-					defaultValue: suggestedBranch,
-					placeholder: suggestedBranch,
-				});
-				if (clack.isCancel(branchInput)) {
-					throw new Error("Cancelled.");
-				}
-				branch = branchInput;
-			}
-
-			let baseBranch: string;
-			if (opts.baseBranch) {
-				baseBranch = opts.baseBranch;
-			} else {
-				const detectedDefault = config?.baseBranch ?? defaultBranch();
-				const baseBranchInput = await clack.text({
-					message: "Base branch / PR target:",
-					defaultValue: detectedDefault,
-					placeholder: detectedDefault,
-				});
-				if (clack.isCancel(baseBranchInput)) {
-					throw new Error("Cancelled.");
-				}
-				baseBranch = baseBranchInput;
-			}
+			// ---- Persist wizard state ----
+			const prMode = draft ? "draft" : "ready";
+			setWizardState(source.name, { branch, baseBranch, prMode });
 
-			const runnerName: string = opts.runner ?? config?.runner ?? "claude";
-			await executeLocal(source.name, branch, baseBranch, iterations, runnerName);
+			await executeLocal(source.name, branch, baseBranch, iterations, runnerName, draft);
 		});
 
 	program

package/src/config.ts

@@ -9,6 +9,8 @@ import { join } from "path";
 
 /** Shape of `.stonecut/config.json`. All fields are optional. */
 export interface StonecutConfig {
+	agent?: string;
+	/** @deprecated Use `agent` instead. Kept for backward compatibility with existing configs. */
 	runner?: string;
 	baseBranch?: string;
 	branchPrefix?: string;
@@ -47,7 +49,7 @@ export function writeDefaultConfig(cwd?: string): void {
 	mkdirSync(dir, { recursive: true });
 
 	const defaults: StonecutConfig = {
-		runner: "claude",
+		agent: "claude",
 		baseBranch: "main",
 		branchPrefix: "stonecut/",
 	};

package/src/execute.ts

@@ -45,7 +45,7 @@ export function buildReport(
 	runnerName: string,
 	closingRefs?: string[],
 ): string {
-	const lines = ["## Stonecut Report", `**Runner:** ${runnerName}`, ""];
+	const lines = ["## Stonecut Report", `**Agent:** ${runnerName}`, ""];
 	for (const r of results) {
 		const metrics = formatMetrics(r);
 		if (r.success) {
@@ -72,13 +72,14 @@ export async function pushAndMaybePr(
 	results: IterationResult[],
 	source: {
 		getRemainingCount(): Promise<[number, number]>;
-		getClosingRefs?(completedIssueNumbers: number[]): string[];
+		getClosingRefs?(): string[];
 	},
 	branch: string,
 	baseBranch: string,
 	prTitle: string,
 	runnerName: string,
 	logger: { log(message: string): void },
+	draft = false,
 ): Promise<void> {
 	if (!results.some((r) => r.success)) {
 		return;
@@ -89,11 +90,10 @@ export async function pushAndMaybePr(
 
 	const [remaining, total] = await source.getRemainingCount();
 	if (remaining === 0) {
-		const completed = results.filter((r) => r.success).map((r) => r.issueNumber);
-		const closingRefs = source.getClosingRefs?.(completed);
+		const closingRefs = source.getClosingRefs?.();
 		const body = buildReport(results, runnerName, closingRefs);
-		createPr(prTitle, body, baseBranch);
-		logger.log("Created PR.");
+		const prUrl = createPr(prTitle, body, baseBranch, draft);
+		logger.log(`Created PR: ${prUrl}`);
 	} else {
 		logger.log(`${remaining}/${total} issues remaining — PR deferred.`);
 	}
@@ -115,6 +115,7 @@ export async function executeLocal(
 	baseBranch: string,
 	iterations: number | "all",
 	runnerName: string,
+	draft = false,
 ): Promise<void> {
 	const source = new LocalSource(name);
 	const logger = new Logger();
@@ -151,6 +152,7 @@ export async function executeLocal(
 			`Stonecut: ${name}`,
 			runnerName,
 			logger,
+			draft,
 		);
 	} finally {
 		logger.close();

package/src/git.ts

@@ -8,6 +8,15 @@
 import { runSync } from "./spawn";
 import type { WorkingTreeSnapshot } from "./types";
 
+/** Return the name of the currently checked-out branch (empty on detached HEAD). */
+export function currentBranch(cwd?: string): string {
+	const result = runSync(["git", "branch", "--show-current"], cwd);
+	if (result.exitCode !== 0) {
+		throw new Error(`Failed to detect current branch: ${result.stderr.trim()}`);
+	}
+	return result.stdout.trim();
+}
+
 /** Detect the remote's default branch, falling back to "main". */
 export function defaultBranch(cwd?: string): string {
 	const result = runSync(["git", "symbolic-ref", "refs/remotes/origin/HEAD"], cwd);
@@ -56,22 +65,17 @@ export function pushBranch(branch: string, cwd?: string): void {
 	}
 }
 
-/** Create a pull request via the gh CLI. */
-export function createPr(title: string, body: string, baseBranch: string): void {
-	const result = runSync([
-		"gh",
-		"pr",
-		"create",
-		"--title",
-		title,
-		"--body",
-		body,
-		"--base",
-		baseBranch,
-	]);
+/** Create a pull request via the gh CLI. Returns the PR URL from stdout. */
+export function createPr(title: string, body: string, baseBranch: string, draft = false): string {
+	const cmd = ["gh", "pr", "create", "--title", title, "--body", body, "--base", baseBranch];
+	if (draft) {
+		cmd.push("--draft");
+	}
+	const result = runSync(cmd);
 	if (result.exitCode !== 0) {
 		throw new Error(`Failed to create PR: ${result.stderr.trim()}`);
 	}
+	return result.stdout.trim();
 }
 
 // ---------------------------------------------------------------------------

package/src/local.ts

@@ -2,9 +2,64 @@
 
 import { existsSync, readdirSync, readFileSync, writeFileSync, appendFileSync, statSync } from "fs";
 import { join } from "path";
-import type { Issue, Source } from "./types";
+import type { Issue, Source, WizardState, StatusData } from "./types";
 import { parseFrontmatter } from "./frontmatter";
 
+// ---------------------------------------------------------------------------
+// Standalone wizard-state helpers (no directory validation required)
+// ---------------------------------------------------------------------------
+
+function statusPathFor(specName: string): string {
+	if (!specName || specName.includes("..") || specName.includes("/") || specName.includes("\\")) {
+		throw new Error(`Invalid spec name: ${specName}`);
+	}
+	return join(".stonecut", "specs", specName, "status.json");
+}
+
+/** Read wizard state from status.json without constructing a full LocalSource. */
+export function getWizardState(specName: string): WizardState {
+	const path = statusPathFor(specName);
+	if (!existsSync(path)) return {};
+	let parsed: unknown;
+	try {
+		parsed = JSON.parse(readFileSync(path, "utf-8"));
+	} catch {
+		return {};
+	}
+	if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return {};
+	const data = parsed as Partial<StatusData>;
+	const state: WizardState = {};
+	if (data.branch !== undefined) state.branch = data.branch;
+	if (data.baseBranch !== undefined) state.baseBranch = data.baseBranch;
+	if (data.prMode !== undefined) state.prMode = data.prMode;
+	return state;
+}
+
+/** Write wizard state to status.json without constructing a full LocalSource. */
+export function setWizardState(specName: string, state: WizardState): void {
+	const path = statusPathFor(specName);
+	let data: Partial<StatusData> = { completed: [] };
+	if (existsSync(path)) {
+		try {
+			const parsed: unknown = JSON.parse(readFileSync(path, "utf-8"));
+			if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+				data = parsed as Partial<StatusData>;
+				if (!Array.isArray(data.completed)) data.completed = [];
+			}
+		} catch {
+			// malformed JSON — fall through with default
+		}
+	}
+	if (state.branch !== undefined) data.branch = state.branch;
+	if (state.baseBranch !== undefined) data.baseBranch = state.baseBranch;
+	if (state.prMode !== undefined) data.prMode = state.prMode;
+	writeFileSync(path, JSON.stringify(data, null, 2) + "\n");
+}
+
+// ---------------------------------------------------------------------------
+// LocalSource
+// ---------------------------------------------------------------------------
+
 export class LocalSource implements Source<Issue> {
 	readonly name: string;
 	private readonly specDir: string;
@@ -86,8 +141,8 @@ export class LocalSource implements Source<Issue> {
 		return null;
 	}
 
-	getClosingRefs(completedIssueNumbers: number[]): string[] {
-		const completed = new Set(completedIssueNumbers);
+	getClosingRefs(): string[] {
+		const completed = this.readStatus();
 		const refs: string[] = [];
 		const all = this.allIssues();
 
@@ -120,10 +175,18 @@ export class LocalSource implements Source<Issue> {
 		return [remaining, total];
 	}
 
+	getWizardState(): WizardState {
+		return getWizardState(this.name);
+	}
+
+	setWizardState(state: WizardState): void {
+		setWizardState(this.name, state);
+	}
+
 	async completeIssue(issue: Issue): Promise<void> {
 		// Update status.json
 		const path = this.statusPath();
-		let data: { completed: number[] };
+		let data: StatusData;
 		if (existsSync(path)) {
 			data = JSON.parse(readFileSync(path, "utf-8"));
 		} else {

package/src/prd.ts

@@ -51,14 +51,15 @@ export function scanLocalPrds(baseDir: string = ".stonecut/specs"): LocalPrdEntr
 
 		entries.push({ name, completed, total });
 	}
-	return entries.sort((a, b) => a.name.localeCompare(b.name));
+	return entries
+		.filter((e) => e.total > 0 && e.completed < e.total)
+		.sort((a, b) => a.name.localeCompare(b.name));
 }
 
 /**
  * Format a PRD entry for display in the wizard.
  */
 export function formatPrdOption(entry: LocalPrdEntry): string {
-	if (entry.total === 0) return `${entry.name} (no issues)`;
 	if (entry.completed === 0) return `${entry.name} (not started)`;
 	return `${entry.name} (${entry.completed}/${entry.total} done)`;
 }

package/src/runners/index.ts

@@ -11,6 +11,11 @@ const RUNNERS: Record<string, new (logger: LogWriter) => Runner> = {
 	codex: CodexRunner,
 };
 
+/** Return sorted list of registered runner names. */
+export function availableRunners(): string[] {
+	return Object.keys(RUNNERS).sort();
+}
+
 export function getRunner(name: string, logger: LogWriter): Runner {
 	const Cls = RUNNERS[name];
 	if (!Cls) {

package/src/types.ts

@@ -53,6 +53,24 @@ export interface GitOps {
 	revertUncommitted(snapshot: WorkingTreeSnapshot): void;
 }
 
+/** PR mode for wizard persistence. */
+export type PrMode = "ready" | "draft";
+
+/** Persistent wizard state stored in status.json. */
+export interface WizardState {
+	branch?: string;
+	baseBranch?: string;
+	prMode?: PrMode;
+}
+
+/** Full status.json schema. */
+export interface StatusData {
+	completed: number[];
+	branch?: string;
+	baseBranch?: string;
+	prMode?: PrMode;
+}
+
 /** A single issue from a local spec. */
 export interface Issue {
 	number: number;