stonecut 1.4.0 → 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.0",
+  "version": "1.5.0",
   "description": "CLI that drives PRD-driven development with agentic coding CLIs",
   "license": "MIT",
   "repository": {
@@ -32,9 +32,7 @@
     "prepare": "husky"
   },
   "dependencies": {
-    "@anthropic-ai/claude-agent-sdk": "^0.2.92",
     "@clack/prompts": "^0.10.0",
-    "@openai/codex-sdk": "^0.118.0",
     "commander": "^13.1.0"
   },
   "lint-staged": {

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

@@ -11,7 +11,6 @@
 
 import { checkoutOrCreateBranch, createPr, pushBranch } from "./git";
 import { LocalSource } from "./local";
-import { slugifyBranchComponent } from "./naming";
 import { renderLocal } from "./prompt";
 import { Logger } from "./logger";
 import { defaultGitOps, formatTokens, runAfkLoop } from "./runner";
@@ -46,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) {
@@ -73,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;
@@ -90,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.`);
 	}
@@ -116,15 +115,16 @@ export async function executeLocal(
 	baseBranch: string,
 	iterations: number | "all",
 	runnerName: string,
+	draft = false,
 ): Promise<void> {
 	const source = new LocalSource(name);
-	const prdIdentifier = slugifyBranchComponent(name) || "spec";
-	const logger = new Logger(prdIdentifier);
+	const logger = new Logger();
 	const runner = getRunner(runnerName, logger);
 
 	const session: Session = { logger, git: defaultGitOps, runner, runnerName };
 
 	try {
+		logger.logFile(`PRD: ${name}`);
 		checkoutOrCreateBranch(branch);
 		console.log("");
 
@@ -152,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/logger.ts

@@ -14,10 +14,11 @@ export class Logger implements LogWriter {
 	private warnedRecreated = false;
 	private warnedUnavailable = false;
 
-	constructor(prdIdentifier: string) {
-		const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+	constructor() {
+		const now = new Date();
+		const timestamp = `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, "0")}-${String(now.getDate()).padStart(2, "0")}T${String(now.getHours()).padStart(2, "0")}-${String(now.getMinutes()).padStart(2, "0")}-${String(now.getSeconds()).padStart(2, "0")}`;
 		const logDir = resolve(".stonecut", "logs");
-		this.filePath = join(logDir, `${prdIdentifier}-${timestamp}.log`);
+		this.filePath = join(logDir, `${timestamp}.log`);
 		try {
 			mkdirSync(logDir, { recursive: true });
 			appendFileSync(this.filePath, "");

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/claude.ts

@@ -1,36 +1,79 @@
 /**
- * ClaudeRunner — adapter for Claude Code via the Agent SDK.
+ * ClaudeRunner — adapter for Claude Code via CLI subprocess.
  *
- * Calls query() from @anthropic-ai/claude-agent-sdk and consumes the
- * async message stream internally. Console gets concise progress
- * (tool calls, turn boundaries, errors); the log file captures the
- * full event stream for debugging.
+ * Spawns `claude --print --output-format stream-json --verbose` and
+ * consumes stdout as newline-delimited JSON. Console gets concise
+ * progress (tool calls, errors); the log file captures the full
+ * event stream for debugging.
  */
 
-import { query as sdkQuery } from "@anthropic-ai/claude-agent-sdk";
-import type {
-	Query,
-	SDKAssistantMessage,
-	SDKMessage,
-	SDKPartialAssistantMessage,
-	SDKResultMessage,
-} from "@anthropic-ai/claude-agent-sdk";
-import type { LogWriter, Runner, RunResult } from "../types.js";
-
-const ALLOWED_TOOLS = ["Bash", "Edit", "Read", "Write", "Glob", "Grep"];
-
-type QueryFn = (params: { prompt: string; options?: Record<string, unknown> }) => Query;
-let queryFn: QueryFn = sdkQuery;
-
-/** @internal Replace the SDK query function. Returns a restore function. */
-export function _setQueryFn(fn: QueryFn): () => void {
-	const prev = queryFn;
-	queryFn = fn;
+import type { ChildResult, LogWriter, Runner, RunResult, SpawnFn } from "../types.js";
+
+const CLI_ARGS = [
+	"claude",
+	"--print",
+	"--output-format",
+	"stream-json",
+	"--verbose",
+	"--allowedTools",
+	"Bash,Edit,Read,Write,Glob,Grep",
+	"--permission-mode",
+	"acceptEdits",
+	"--no-session-persistence",
+];
+
+// ---------------------------------------------------------------------------
+// Subprocess spawning (injectable for tests)
+// ---------------------------------------------------------------------------
+
+async function* readLines(stream: ReadableStream<Uint8Array>): AsyncGenerator<string> {
+	const reader = stream.getReader();
+	const decoder = new TextDecoder();
+	let buffer = "";
+	try {
+		while (true) {
+			const { done, value } = await reader.read();
+			if (done) break;
+			buffer += decoder.decode(value, { stream: true });
+			const lines = buffer.split("\n");
+			buffer = lines.pop()!;
+			for (const line of lines) {
+				if (line.trim()) yield line;
+			}
+		}
+		if (buffer.trim()) yield buffer;
+	} finally {
+		reader.releaseLock();
+	}
+}
+
+function defaultSpawn(cmd: string[], stdin: string): ChildResult {
+	const proc = Bun.spawn(cmd, {
+		stdin: new Blob([stdin]),
+		stdout: "pipe",
+		stderr: "ignore",
+	});
+	return {
+		lines: readLines(proc.stdout),
+		exitCode: proc.exited,
+	};
+}
+
+let spawnFn: SpawnFn = defaultSpawn;
+
+/** @internal Replace the spawn function. Returns a restore function. */
+export function _setSpawnFn(fn: SpawnFn): () => void {
+	const prev = spawnFn;
+	spawnFn = fn;
 	return () => {
-		queryFn = prev;
+		spawnFn = prev;
 	};
 }
 
+// ---------------------------------------------------------------------------
+// Error subtype mapping
+// ---------------------------------------------------------------------------
+
 const ERROR_MESSAGES: Record<string, string> = {
 	error_max_turns: "max turns exceeded",
 	error_max_budget_usd: "max budget exceeded",
@@ -38,34 +81,23 @@ const ERROR_MESSAGES: Record<string, string> = {
 	error_max_structured_output_retries: "max structured output retries exceeded",
 };
 
+// ---------------------------------------------------------------------------
+// Runner implementation
+// ---------------------------------------------------------------------------
+
 export class ClaudeRunner implements Runner {
 	private logger: LogWriter;
 
 	constructor(logger: LogWriter) {
 		this.logger = logger;
-		const configDir = process.env.CLAUDE_CONFIG_DIR || "~/.claude (default)";
-		logger.log(`Claude config: ${configDir}`);
 	}
 
 	async run(prompt: string): Promise<RunResult> {
 		const start = performance.now();
-		let result: SDKResultMessage | undefined;
+		let child: ChildResult;
 
 		try {
-			const stream = queryFn({
-				prompt,
-				options: {
-					allowedTools: ALLOWED_TOOLS,
-					permissionMode: "acceptEdits",
-				},
-			});
-
-			for await (const message of stream) {
-				this.handleMessage(message);
-				if (message.type === "result") {
-					result = message;
-				}
-			}
+			child = spawnFn(CLI_ARGS, prompt);
 		} catch (error: unknown) {
 			const durationSeconds = (performance.now() - start) / 1000;
 			const msg = error instanceof Error ? error.message : String(error);
@@ -76,16 +108,46 @@ export class ClaudeRunner implements Runner {
 			return { success: false, durationSeconds, error: msg };
 		}
 
+		let result: Record<string, unknown> | undefined;
+
+		try {
+			for await (const line of child.lines) {
+				let parsed: Record<string, unknown>;
+				try {
+					parsed = JSON.parse(line);
+				} catch {
+					this.logger.logFile(`[claude] Malformed JSON line: ${line}`);
+					continue;
+				}
+
+				this.handleMessage(parsed);
+
+				if (parsed.type === "result") {
+					result = parsed;
+				}
+			}
+		} catch (error: unknown) {
+			const durationSeconds = (performance.now() - start) / 1000;
+			const msg = error instanceof Error ? error.message : String(error);
+			return { success: false, durationSeconds, error: msg };
+		}
+
+		const exitCode = await child.exitCode;
 		const durationSeconds = (performance.now() - start) / 1000;
 
+		if (exitCode !== 0) {
+			return { success: false, durationSeconds, error: `claude exited with code ${exitCode}` };
+		}
+
 		if (!result) {
 			return { success: false, durationSeconds, error: "no result message received" };
 		}
 
-		const sessionId = result.session_id;
-		const turns = result.num_turns;
-		const inputTokens = result.usage.input_tokens;
-		const outputTokens = result.usage.output_tokens;
+		const sessionId = result.session_id as string | undefined;
+		const turns = result.num_turns as number | undefined;
+		const usage = result.usage as { input_tokens?: number; output_tokens?: number } | undefined;
+		const inputTokens = usage?.input_tokens;
+		const outputTokens = usage?.output_tokens;
 
 		this.logger.logFile(
 			`[claude] Result: ${result.subtype}, turns=${turns}, input=${inputTokens}, output=${outputTokens}`,
@@ -95,7 +157,7 @@ export class ClaudeRunner implements Runner {
 			return {
 				success: true,
 				durationSeconds,
-				output: result.result,
+				output: result.result as string | undefined,
 				turns,
 				inputTokens,
 				outputTokens,
@@ -103,8 +165,10 @@ export class ClaudeRunner implements Runner {
 			};
 		}
 
-		const error = ERROR_MESSAGES[result.subtype] ?? `failed (${result.subtype})`;
-		const detail = result.errors?.length ? `: ${result.errors.join("; ")}` : "";
+		const subtype = result.subtype as string;
+		const error = ERROR_MESSAGES[subtype] ?? `failed (${subtype})`;
+		const errors = result.errors as string[] | undefined;
+		const detail = errors?.length ? `: ${errors.join("; ")}` : "";
 		return {
 			success: false,
 			durationSeconds,
@@ -116,13 +180,19 @@ export class ClaudeRunner implements Runner {
 		};
 	}
 
-	private handleMessage(message: SDKMessage): void {
+	// -----------------------------------------------------------------------
+	// Message routing
+	// -----------------------------------------------------------------------
+
+	private handleMessage(message: Record<string, unknown>): void {
 		switch (message.type) {
 			case "assistant":
 				this.logAssistant(message);
 				break;
-			case "stream_event":
-				this.logStreamEvent(message);
+			case "system":
+			case "user":
+			case "rate_limit_event":
+				this.logger.logFile(`[claude] ${message.type}: ${JSON.stringify(message)}`);
 				break;
 			case "result":
 				break;
@@ -132,32 +202,25 @@ export class ClaudeRunner implements Runner {
 		}
 	}
 
-	private logAssistant(message: SDKAssistantMessage): void {
-		if (message.error) {
-			this.logger.log(`[claude] Error: ${message.error}`);
-		}
+	private logAssistant(message: Record<string, unknown>): void {
+		const msgBody = message.message as { content?: unknown[] } | undefined;
+		const content = msgBody?.content;
 
-		for (const block of message.message.content) {
-			if (typeof block === "string") continue;
-			if (block.type === "tool_use") {
-				const target = this.toolTarget(block.name, block.input as Record<string, unknown>);
-				this.logger.log(`[claude] ${block.name}${target ? `: ${target}` : ""}`);
-			}
+		if (!Array.isArray(content)) {
+			this.logger.logFile(`[claude] Assistant message: ${JSON.stringify(message)}`);
+			return;
 		}
 
-		this.logger.logFile(`[claude] Assistant message: ${JSON.stringify(message.message.content)}`);
-	}
-
-	private logStreamEvent(message: SDKPartialAssistantMessage): void {
-		const event = message.event;
-		if (event.type === "content_block_delta") {
-			const delta = event.delta;
-			if ("text" in delta && typeof delta.text === "string") {
-				this.logger.logFile(`[claude] text: ${delta.text}`);
-			} else if ("thinking" in delta && typeof delta.thinking === "string") {
-				this.logger.logFile(`[claude] thinking: ${delta.thinking}`);
+		for (const block of content) {
+			if (typeof block === "string" || block === null || typeof block !== "object") continue;
+			const b = block as Record<string, unknown>;
+			if (b.type === "tool_use") {
+				const target = this.toolTarget(b.name as string, b.input as Record<string, unknown>);
+				this.logger.log(`[claude] ${b.name}${target ? `: ${target}` : ""}`);
 			}
 		}
+
+		this.logger.logFile(`[claude] Assistant message: ${JSON.stringify(content)}`);
 	}
 
 	private toolTarget(name: string, input: Record<string, unknown>): string | undefined {

package/src/runners/codex.ts

@@ -1,27 +1,68 @@
 /**
- * CodexRunner — adapter for OpenAI Codex via the Agent SDK.
+ * CodexRunner — adapter for Codex via CLI subprocess.
  *
- * Creates a Codex client and thread per run(), consumes the async event
- * stream internally. Console gets concise progress (tool calls, file
- * changes, turn boundaries, errors); the log file captures the full
- * event stream for debugging.
+ * Spawns `codex exec --json --dangerously-bypass-approvals-and-sandbox` and
+ * consumes stdout as newline-delimited JSON. Console gets concise
+ * progress (tool calls, file changes, turn boundaries, errors); the log
+ * file captures the full event stream for debugging.
  */
 
-import { Codex, type ThreadEvent, type ThreadItem } from "@openai/codex-sdk";
-import type { LogWriter, Runner, RunResult } from "../types.js";
+import type { ChildResult, LogWriter, Runner, RunResult, SpawnFn } from "../types.js";
+
+const CLI_ARGS = ["codex", "exec", "--json", "--dangerously-bypass-approvals-and-sandbox"];
+
+// ---------------------------------------------------------------------------
+// Subprocess spawning (injectable for tests)
+// ---------------------------------------------------------------------------
+
+async function* readLines(stream: ReadableStream<Uint8Array>): AsyncGenerator<string> {
+	const reader = stream.getReader();
+	const decoder = new TextDecoder();
+	let buffer = "";
+	try {
+		while (true) {
+			const { done, value } = await reader.read();
+			if (done) break;
+			buffer += decoder.decode(value, { stream: true });
+			const lines = buffer.split("\n");
+			buffer = lines.pop()!;
+			for (const line of lines) {
+				if (line.trim()) yield line;
+			}
+		}
+		if (buffer.trim()) yield buffer;
+	} finally {
+		reader.releaseLock();
+	}
+}
+
+function defaultSpawn(cmd: string[], stdin: string): ChildResult {
+	const proc = Bun.spawn(cmd, {
+		stdin: new Blob([stdin]),
+		stdout: "pipe",
+		stderr: "ignore",
+	});
+	return {
+		lines: readLines(proc.stdout),
+		exitCode: proc.exited,
+	};
+}
 
-type CodexFactory = (...args: ConstructorParameters<typeof Codex>) => InstanceType<typeof Codex>;
-let createCodex: CodexFactory = (...args) => new Codex(...args);
+let spawnFn: SpawnFn = defaultSpawn;
 
-/** @internal Replace the Codex factory. Returns a restore function. */
-export function _setCodexFactory(fn: CodexFactory): () => void {
-	const prev = createCodex;
-	createCodex = fn;
+/** @internal Replace the spawn function. Returns a restore function. */
+export function _setSpawnFn(fn: SpawnFn): () => void {
+	const prev = spawnFn;
+	spawnFn = fn;
 	return () => {
-		createCodex = prev;
+		spawnFn = prev;
 	};
 }
 
+// ---------------------------------------------------------------------------
+// Runner implementation
+// ---------------------------------------------------------------------------
+
 export class CodexRunner implements Runner {
 	private logger: LogWriter;
 
@@ -31,6 +72,19 @@ export class CodexRunner implements Runner {
 
 	async run(prompt: string): Promise<RunResult> {
 		const start = performance.now();
+		let child: ChildResult;
+
+		try {
+			child = spawnFn(CLI_ARGS, prompt);
+		} catch (error: unknown) {
+			const durationSeconds = (performance.now() - start) / 1000;
+			const msg = error instanceof Error ? error.message : String(error);
+
+			if (msg.includes("ENOENT") || (error as NodeJS.ErrnoException)?.code === "ENOENT") {
+				return { success: false, durationSeconds, error: "codex binary not found in PATH" };
+			}
+			return { success: false, durationSeconds, error: msg };
+		}
 
 		let threadId: string | undefined;
 		let turns = 0;
@@ -41,58 +95,68 @@ export class CodexRunner implements Runner {
 		let errorMessage: string | undefined;
 
 		try {
-			const codex = createCodex();
-			const thread = codex.startThread({
-				approvalPolicy: "never",
-				sandboxMode: "danger-full-access",
-			});
-
-			const { events } = await thread.runStreamed(prompt);
+			for await (const line of child.lines) {
+				let parsed: Record<string, unknown>;
+				try {
+					parsed = JSON.parse(line);
+				} catch {
+					this.logger.logFile(`[codex] Malformed JSON line: ${line}`);
+					continue;
+				}
 
-			for await (const event of events) {
-				this.handleEvent(event);
+				this.logger.logFile(`[codex] ${parsed.type}: ${JSON.stringify(parsed)}`);
 
-				switch (event.type) {
+				switch (parsed.type) {
 					case "thread.started":
-						threadId = event.thread_id;
+						threadId = parsed.thread_id as string;
 						break;
 					case "turn.started":
 						turns++;
+						completed = false;
 						break;
 					case "turn.completed":
 						completed = true;
 						this.logger.log(`[codex] Turn ${turns} completed`);
-						inputTokens += event.usage.input_tokens;
-						outputTokens += event.usage.output_tokens;
+						{
+							const usage = parsed.usage as
+								| { input_tokens?: number; output_tokens?: number }
+								| undefined;
+							inputTokens += usage?.input_tokens ?? 0;
+							outputTokens += usage?.output_tokens ?? 0;
+						}
 						break;
 					case "turn.failed":
 						failed = true;
-						errorMessage = event.error.message;
+						{
+							const err = parsed.error as { message?: string } | undefined;
+							errorMessage = err?.message ?? "codex turn failed";
+						}
 						this.logger.log(`[codex] Error: ${errorMessage}`);
 						break;
 					case "error":
 						failed = true;
-						errorMessage = event.message;
+						errorMessage = parsed.message as string;
 						this.logger.log(`[codex] Error: ${errorMessage}`);
 						break;
 					case "item.started":
 					case "item.completed":
-						this.logItem(event.type, event.item);
+						this.logItem(parsed.type, parsed.item as Record<string, unknown>);
 						break;
 				}
 			}
 		} catch (error: unknown) {
 			const durationSeconds = (performance.now() - start) / 1000;
 			const msg = error instanceof Error ? error.message : String(error);
-
-			if (msg.includes("ENOENT") || msg.includes("not found") || msg.includes("spawn")) {
-				return { success: false, durationSeconds, error: "codex binary not found in PATH" };
-			}
 			return { success: false, durationSeconds, error: msg };
 		}
 
+		const exitCode = await child.exitCode;
 		const durationSeconds = (performance.now() - start) / 1000;
 
+		if (exitCode !== 0) {
+			return { success: false, durationSeconds, error: `codex exited with code ${exitCode}` };
+		}
+
 		const status = failed ? "failed" : completed ? "success" : "incomplete";
 		this.logger.logFile(
 			`[codex] Result: ${status}, turns=${turns}, input=${inputTokens}, output=${outputTokens}`,
@@ -132,21 +196,19 @@ export class CodexRunner implements Runner {
 		};
 	}
 
-	private handleEvent(event: ThreadEvent): void {
-		this.logger.logFile(`[codex] ${event.type}: ${JSON.stringify(event)}`);
-	}
-
-	private logItem(phase: "item.started" | "item.completed", item: ThreadItem): void {
+	private logItem(phase: string, item: Record<string, unknown>): void {
 		switch (item.type) {
 			case "command_execution":
-				if (phase === "item.started") {
+				if (phase === "item.started" && typeof item.command === "string") {
 					this.logger.log(`[codex] Bash: ${item.command.slice(0, 80)}`);
 				}
 				break;
 			case "file_change":
-				if (phase === "item.completed") {
+				if (phase === "item.completed" && Array.isArray(item.changes)) {
 					for (const change of item.changes) {
-						this.logger.log(`[codex] Edit: ${change.path}`);
+						if (typeof change?.path === "string") {
+							this.logger.log(`[codex] Edit: ${change.path}`);
+						}
 					}
 				}
 				break;

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

@@ -2,6 +2,15 @@
  * Core types and interfaces shared across the Stonecut CLI.
  */
 
+/** Return type from SpawnFn — stdout line stream and process exit code. */
+export interface ChildResult {
+	lines: AsyncIterable<string>;
+	exitCode: Promise<number>;
+}
+
+/** Injectable subprocess factory for runner testing. */
+export type SpawnFn = (cmd: string[], stdin: string) => ChildResult;
+
 /** Structured result from a single runner execution. */
 export interface RunResult {
 	success: boolean;
@@ -44,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;