Rename prd-forge to stonecut (#108)

Rename the project, CLI command, skill names, directory conventions,
and all references across source, tests, and documentation.

- Package: prd-forge → stonecut
- CLI command: forge → stonecut
- Local dir: .forge/ → .stonecut/
- Skills: forge-{interview,prd,issues} → stonecut-{interview,prd,issues}
- Branch pattern: forge/<slug> → stonecut/<slug>
- Remove legacy skill migration code (forge:* and forge-*)

Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: elkinjosetm

DESIGN.md

@@ -1,20 +1,20 @@
-# Forge — Design Document
+# Stonecut — Design Document
 
-Forge is a CLI tool that executes PRD-driven development workflows using agentic coding CLIs. It picks up issues (vertical slices from a PRD), spawns headless CLI sessions to implement them, handles bookkeeping, and creates pull requests with execution reports.
+Stonecut is a CLI tool that executes PRD-driven development workflows using agentic coding CLIs. It picks up issues (vertical slices from a PRD), spawns headless CLI sessions to implement them, handles bookkeeping, and creates pull requests with execution reports.
 
 This document captures the design decisions for the initial build and future roadmap.
 
 ## Naming
 
-- **Project name:** Forge (repo: forge-orchestrator)
-- **CLI command:** `forge`
-- **Rationale:** A PRD is a blueprint, issues are the pieces, the tool forges them into reality. The primary execution entry point is `forge run`, with source selection handled by flags.
+- **Project name:** Stonecut (repo: stonecut)
+- **CLI command:** `stonecut`
+- **Rationale:** A PRD is a blueprint, issues are the pieces, the tool cuts them precisely into reality. The primary execution entry point is `stonecut run`, with source selection handled by flags.
 
 ## CLI Commands
 
 ```
-forge run --local <name> -i <N|all> [--runner <name>]
-forge run --github <number> -i <N|all> [--runner <name>]
+stonecut run --local <name> -i <N|all> [--runner <name>]
+stonecut run --github <number> -i <N|all> [--runner <name>]
 ```
 
 ### Flags
@@ -29,12 +29,12 @@ forge run --github <number> -i <N|all> [--runner <name>]
 
 ### Sources
 
-- **`forge run --local <name>`** — local PRD. Looks in `.forge/<name>/` for `prd.md` and `issues/`.
-- **`forge run --github <number>`** — GitHub PRD. Issue number on the current repo, tasks are sub-issues.
+- **`stonecut run --local <name>`** — local PRD. Looks in `.stonecut/<name>/` for `prd.md` and `issues/`.
+- **`stonecut run --github <number>`** — GitHub PRD. Issue number on the current repo, tasks are sub-issues.
 
 ## Runner Architecture
 
-Forge uses a runner abstraction to support multiple agentic coding CLIs. The architecture consists of:
+Stonecut uses a runner abstraction to support multiple agentic coding CLIs. The architecture consists of:
 
 ### Runner Interface
 
@@ -81,27 +81,27 @@ Modules throw typed errors. Only `cli.ts` catches errors, formats user-facing me
    - On success: close issue / update `status.json`, log to `progress.txt`.
    - On failure: record error, move on.
 6. Loops until iterations exhausted.
-7. After all iterations: push branch, create PR with Forge Report.
+7. After all iterations: push branch, create PR with Stonecut Report.
 
 ### Prompt
 
 Single `execute.md` template with placeholders. The template is CLI-agnostic — runner-specific behavior is encapsulated in the adapter, not the prompt.
 
 ## Pre-execution Flow
 
-Before spawning the first session, Forge prompts the user:
+Before spawning the first session, Stonecut prompts the user:
 
-1. **Branch name** — with a sensible suggestion using the unified `forge/<slug>` convention. Local mode uses the spec name, GitHub mode uses the PRD title slug, and GitHub falls back to `forge/issue-<number>` when needed.
+1. **Branch name** — with a sensible suggestion using the unified `stonecut/<slug>` convention. Local mode uses the spec name, GitHub mode uses the PRD title slug, and GitHub falls back to `stonecut/issue-<number>` when needed.
 2. **Base branch / PR target** — suggests `main`.
 
 Interactive prompts use `@clack/prompts`.
 
 ## PR Report
 
-At the end of a run, Forge pushes the branch and creates a PR with a report:
+At the end of a run, Stonecut pushes the branch and creates a PR with a report:
 
 ```markdown
-## Forge Report
+## Stonecut Report
 
 **Runner:** claude
 
@@ -114,21 +114,21 @@ In GitHub mode, the PR title is the PRD issue title, with `PRD #<number>` as the
 
 ## Local Spec Structure
 
-Local specs live in `.forge/` at the repo root:
+Local specs live in `.stonecut/` at the repo root:
 
 ```
-.forge/
+.stonecut/
 └── my-feature/
     ├── prd.md                    # The PRD (created by write-a-prd skill)
     ├── issues/
     │   ├── 01-setup.md           # Vertical slice issues (created by prd-to-issues skill)
     │   ├── 02-core.md
     │   └── 03-api.md
-    ├── status.json               # Auto-created by Forge
-    └── progress.txt              # Auto-created by Forge
+    ├── status.json               # Auto-created by Stonecut
+    └── progress.txt              # Auto-created by Stonecut
 ```
 
-Whether `.forge/` is gitignored is the developer's decision per repo. Forge does not touch `.gitignore`.
+Whether `.stonecut/` is gitignored is the developer's decision per repo. Stonecut does not touch `.gitignore`.
 
 ## GitHub Mode
 
@@ -148,7 +148,7 @@ Whether `.forge/` is gitignored is the developer's decision per repo. Forge does
 ## Project Structure
 
 ```
-prd-forge/
+stonecut/
 ├── package.json
 ├── tsconfig.json
 ├── src/
@@ -168,9 +168,9 @@ prd-forge/
 │   ├── templates/
 │   │   └── execute.md      # prompt template
 │   └── skills/
-│       ├── forge-interview/
-│       ├── forge-prd/
-│       └── forge-issues/
+│       ├── stonecut-interview/
+│       ├── stonecut-prd/
+│       └── stonecut-issues/
 └── tests/
     ├── cli.test.ts
     ├── local.test.ts
@@ -190,24 +190,24 @@ Skills remain as Claude Code skills. They are not invoked by the CLI on day one
 
 ## Pipeline
 
-Ideas can come from anywhere — a GitHub issue, a Jira ticket, a Slack thread, an MCP server, or just a conversation. Forge doesn't prescribe where ideas originate. The pipeline starts once you're ready to act on one:
+Ideas can come from anywhere — a GitHub issue, a Jira ticket, a Slack thread, an MCP server, or just a conversation. Stonecut doesn't prescribe where ideas originate. The pipeline starts once you're ready to act on one:
 
-1. **Interview** — Stress-test the idea via `/forge-interview`.
-2. **PRD** — Write the spec via `/forge-prd`. Saves to a local file (`.forge/<name>/prd.md`) or a GitHub issue labeled `prd`.
-3. **Issues** — Break the PRD into vertical slices via `/forge-issues`. Creates local markdown files or GitHub sub-issues.
-4. **Execute** — `forge run` picks up the issues and implements them sequentially.
+1. **Interview** — Stress-test the idea via `/stonecut-interview`.
+2. **PRD** — Write the spec via `/stonecut-prd`. Saves to a local file (`.stonecut/<name>/prd.md`) or a GitHub issue labeled `prd`.
+3. **Issues** — Break the PRD into vertical slices via `/stonecut-issues`. Creates local markdown files or GitHub sub-issues.
+4. **Execute** — `stonecut run` picks up the issues and implements them sequentially.
 
 ### Suggested practice: managing your idea backlog with GitHub labels
 
 For projects using GitHub issues, we recommend a label-driven flow to track ideas before they enter the pipeline:
 
 1. **Capture** — Create a GitHub issue with the `roadmap` label. This is the idea backlog entry, regardless of where the idea originated.
-2. **Interview** — Run `/forge-interview` on the idea. Discussion happens on the roadmap issue.
-3. **PRD** — Run `/forge-prd`. The roadmap issue is closed with a comment linking forward to the new PRD issue. The PRD issue is created with the `prd` label and links back to the roadmap issue for history.
-4. **Issues** — Run `/forge-issues`. Sub-issues are created and linked to the PRD issue.
-5. **Execute** — `forge run --github <prd_number>` implements the sub-issues. Each is closed on completion.
-6. **PR** — Forge pushes the branch and creates a PR. The PR body includes "Closes #prd_number", so the PRD issue is auto-closed when the PR merges.
+2. **Interview** — Run `/stonecut-interview` on the idea. Discussion happens on the roadmap issue.
+3. **PRD** — Run `/stonecut-prd`. The roadmap issue is closed with a comment linking forward to the new PRD issue. The PRD issue is created with the `prd` label and links back to the roadmap issue for history.
+4. **Issues** — Run `/stonecut-issues`. Sub-issues are created and linked to the PRD issue.
+5. **Execute** — `stonecut run --github <prd_number>` implements the sub-issues. Each is closed on completion.
+6. **PR** — Stonecut pushes the branch and creates a PR. The PR body includes "Closes #prd_number", so the PRD issue is auto-closed when the PR merges.
 
 This keeps each artifact (idea, spec, implementation tickets) as a separate issue with a clear purpose and traceable lineage.
 
-See [GitHub issues labeled `roadmap`](https://github.com/elkinjosetm/prd-forge/labels/roadmap) for current ideas.
+See [GitHub issues labeled `roadmap`](https://github.com/elkinjosetm/stonecut/labels/roadmap) for current ideas.

NOTICE.md

@@ -2,7 +2,7 @@
 
 ## Skills
 
-The skills in `src/skills/` (`forge-interview`, `forge-prd`, `forge-issues`) are
+The skills in `src/skills/` (`stonecut-interview`, `stonecut-prd`, `stonecut-issues`) are
 derived from works by **Matt Pocock**, originally published under the MIT License at:
 
 - [grill-me](https://github.com/mattpocock/skills/tree/main/grill-me)
@@ -16,7 +16,7 @@ Original copyright notice:
 
 ## Technique
 
-The autonomous agentic execution loop used by the `forge` CLI is inspired by the
+The autonomous agentic execution loop used by the `stonecut` CLI is inspired by the
 **Ralph technique**, conceived by **Geoffrey Huntley** and described at:
 
 - https://ghuntley.com/ralph/

README.md

@@ -1,17 +1,17 @@
-# PRD Forge
+# Stonecut
 
-A CLI that drives PRD-driven development with agentic coding CLIs. You write the PRD, Forge executes the issues one by one.
+A CLI that drives PRD-driven development with agentic coding CLIs. You write the PRD, Stonecut executes the issues one by one.
 
 ## Workflow
 
 Ideas can come from anywhere — Jira tickets, Slack threads, MCP servers, or just a conversation. The pipeline starts once you're ready to act on one:
 
-1. **`/forge-interview`** — Stress-test the idea. Get grilled on the plan until it's solid.
-2. **`/forge-prd`** — Turn the validated idea into a PRD (local file or GitHub issue).
-3. **`/forge-issues`** — Break the PRD into independently-grabbable issues (local markdown files or GitHub sub-issues).
-4. **`forge run`** — Execute the issues sequentially with an agentic coding CLI.
+1. **`/stonecut-interview`** — Stress-test the idea. Get grilled on the plan until it's solid.
+2. **`/stonecut-prd`** — Turn the validated idea into a PRD (local file or GitHub issue).
+3. **`/stonecut-issues`** — Break the PRD into independently-grabbable issues (local markdown files or GitHub sub-issues).
+4. **`stonecut run`** — Execute the issues sequentially with an agentic coding CLI.
 
-Steps 1–3 are Claude Code skills installed via `forge setup-skills`. Step 4 is the Forge CLI.
+Steps 1–3 are Claude Code skills installed via `stonecut setup-skills`. Step 4 is the Stonecut CLI.
 
 ### Suggested: managing your idea backlog
 
@@ -28,20 +28,20 @@ For projects using GitHub issues, we recommend tracking ideas with a `roadmap` l
 ### Install from npm
 
 ```sh
-bun add -g prd-forge
+bun add -g stonecut
 ```
 
-This makes the `forge` command globally available. Then install the Claude Code skills:
+This makes the `stonecut` command globally available. Then install the Claude Code skills:
 
 ```sh
-forge setup-skills
+stonecut setup-skills
 ```
 
 ### Install from source
 
 ```sh
-git clone https://github.com/elkinjosetm/prd-forge.git
-cd prd-forge
+git clone https://github.com/elkinjosetm/stonecut.git
+cd stonecut
 bun install
 ```
 
@@ -68,26 +68,26 @@ bun test
 
 ## Usage
 
-Forge has one execution command (`run`) with two sources (`--local` for local PRDs, `--github` for GitHub PRDs). All execution is headless — Forge runs the issues autonomously and creates a PR when done.
+Stonecut has one execution command (`run`) with two sources (`--local` for local PRDs, `--github` for GitHub PRDs). All execution is headless — Stonecut runs the issues autonomously and creates a PR when done.
 
-### `forge run --local` — Local PRDs
+### `stonecut run --local` — Local PRDs
 
 ```sh
 # Run 5 issues, then push and create a PR
-forge run --local my-feature -i 5
+stonecut run --local my-feature -i 5
 
 # Run all remaining issues
-forge run --local my-feature -i all
+stonecut run --local my-feature -i all
 ```
 
-### `forge run --github` — GitHub PRDs
+### `stonecut run --github` — GitHub PRDs
 
 ```sh
 # Run 5 sub-issues
-forge run --github 42 -i 5
+stonecut run --github 42 -i 5
 
 # Run all remaining sub-issues
-forge run --github 42 -i all
+stonecut run --github 42 -i all
 ```
 
 ### Flags
@@ -100,26 +100,26 @@ forge run --github 42 -i all
 
 ### Pre-execution prompts
 
-Before starting, Forge:
+Before starting, Stonecut:
 
 1. Checks for a clean working tree
-2. Prompts for a branch name (suggests `forge/<slug>` — local uses the spec name, GitHub uses the PRD title slug, with `forge/issue-<number>` fallback)
+2. Prompts for a branch name (suggests `stonecut/<slug>` — local uses the spec name, GitHub uses the PRD title slug, with `stonecut/issue-<number>` fallback)
 3. Prompts for a base branch / PR target (suggests `main`)
 4. Creates or checks out the branch
 
 ### After a run
 
-Forge automatically pushes the branch, creates a PR, and includes a Forge 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, 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.
 In GitHub mode, the PR title defaults to the PRD issue title with a `PRD #<number>` fallback if the title is unavailable.
 
 ## Sources
 
-### Local mode (`forge run --local <name>`)
+### Local mode (`stonecut run --local <name>`)
 
-Expects a local PRD directory at `.forge/<name>/` with this structure:
+Expects a local PRD directory at `.stonecut/<name>/` with this structure:
 
 ```
-.forge/my-feature/
+.stonecut/my-feature/
 ├── prd.md              # The full PRD
 ├── issues/
 │   ├── 01-setup.md     # Issue files, numbered for ordering
@@ -129,7 +129,7 @@ Expects a local PRD directory at `.forge/<name>/` with this structure:
 └── progress.txt        # Auto-created: timestamped completion log
 ```
 
-### GitHub mode (`forge run --github <number>`)
+### GitHub mode (`stonecut run --github <number>`)
 
 Works with GitHub issues instead of local files:
 
@@ -143,20 +143,20 @@ Works with GitHub issues instead of local files:
 The repo ships three Claude Code skills for steps 1–3 of the workflow. Install them with:
 
 ```sh
-forge setup-skills
+stonecut setup-skills
 ```
 
-This creates symlinks in `~/.claude/skills/` pointing to the installed package. Once linked, they're available as `/forge-interview`, `/forge-prd`, and `/forge-issues` in any Claude Code session.
+This creates symlinks in `~/.claude/skills/` pointing to the installed package. Once linked, they're available as `/stonecut-interview`, `/stonecut-prd`, and `/stonecut-issues` in any Claude Code session.
 
 For non-default Claude Code installations, pass `--target` with the Claude root path:
 
 ```sh
-forge setup-skills --target ~/.claude-acme
+stonecut setup-skills --target ~/.claude-acme
 ```
 
 To remove the symlinks:
 
 ```sh
-forge remove-skills              # default (~/.claude)
-forge remove-skills --target ~/.claude-acme
+stonecut remove-skills              # default (~/.claude)
+stonecut remove-skills --target ~/.claude-acme
 ```

package.json

@@ -1,11 +1,11 @@
 {
-  "name": "prd-forge",
+  "name": "stonecut",
   "version": "1.0.0",
   "description": "CLI that drives PRD-driven development with agentic coding CLIs",
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/elkinjosetm/prd-forge.git"
+    "url": "https://github.com/elkinjosetm/stonecut.git"
   },
   "keywords": [
     "cli",
@@ -21,7 +21,7 @@
     "README.md"
   ],
   "bin": {
-    "forge": "./src/cli.ts"
+    "stonecut": "./src/cli.ts"
   },
   "scripts": {
     "lint": "eslint src/ tests/",