@idea1/cli 1.7.6 → 1.8.0

package/README.md

@@ -15,7 +15,7 @@ npm install -g @idea1/cli
 Run commands directly from the command line:
 
 ```bash
-# Put a project item under workflow management (branch + metadata, no code changes)
+# Put a project item under workflow management (branch recorded on idea1.ai, no code changes)
 idea1 start --url https://app.idea1.ai/project/items/590
 
 # Advance the item to its next workflow state (runs that state's automation)
@@ -29,8 +29,10 @@ idea1 start-dev-implementation  # or: idea1 dev
 idea1 ready-for-approval        # or: idea1 rfa
 idea1 approve-pr                # or: idea1 approve
 
-# Carry an integration branch into working/release (opens the PR, assigns its approver; the assignee merges it)
-idea1 integrate                 # or: idea1 int
+# The same two commands on a branch with no project item, e.g. an integration branch:
+# open its PR into working/release and name the approver, then (as the approver) merge it
+idea1 ready-for-approval --assignee octocat
+idea1 approve-pr --branch working/integration/<name>-main
 
 # Release the release branch to production (opens the release PR into main, assigned to you, and merges it once the checks pass)
 idea1 release                   # or: idea1 r
@@ -58,20 +60,22 @@ The state names and their order are defined once, in `shared-config/workflow-sta
 
 ### How the workflow engine works
 
-An item **under workflow management** has exactly one branch on origin that carries `.idea1/<branch>.json` with the item's URL and current `workflowState`. That committed file is the durable, shared record: the idea1.ai web client writes the same file when a state is advanced from the browser, and every CLI command first syncs the branch's state from origin (adopting the metadata into local git config and fast-forwarding a local checkout when it is behind) — so the CLI and the web client never disagree.
+An item **under workflow management** has a *workflow context* on idea1.ai: its workflow status together with the one branch on origin that carries its work — the repository and branch name, the PR target (base) branch, the dev workflow type and any stack or integration branch. An item with no context is outside workflow management and has no status. The CLI reads and records the context through the platform's MCP tools (`get_workflow_context_for_branch`, `get_workflow_context_for_item`, `upsert_workflow_context`) and records state changes with `set_item_workflow_status`; the web client works on the same context, so the two always agree, and any clone resolves a branch to its item from the platform. Locally, each clone remembers the item URL a branch was last resolved to in its git config, so ordinary branches are recognized as unmanaged instantly.
 
-A transition is "enter state X". Entering a state runs that state's automation (a *handler*), then records the new state in the branch metadata, in local git config and on the idea1.ai item. Most states have no automation; the implementation states do:
+The branch itself carries the work. A branch's PR is therefore gated on a CI/CD run of exactly what merges, and `approve-pr` merges that run's head. When a branch is deleted on GitHub the context keeps its name and records whether the work merged; a context whose branch is gone without merging gets a new branch the next time the item enters a pre-merge state, while merged work stays merged. Branches put under workflow before the platform kept contexts carry a legacy `.idea1/<branch>.json` file, which the CLI removes from the branch before the approval gate.
+
+A transition is "enter state X". Entering a state runs that state's automation (a *handler*), then records the new state on the item's context. An item outside workflow management is put under it by the transition itself - the branch is created on origin and the context recorded before any automation runs - so entering the first state is what starts an item. Handlers are idempotent, so a transition replayed after the item was moved back does not repeat work that is already done. Most states have no automation; the implementation states do:
 
 | Entering | Automation |
 |----------|-----------|
 | Build Spec in Progress … Ready for Agent Implementation | none — status only |
 | **Agent Implementation** | ensures the branch is checked out locally (worktree or main repo), then **launches Claude** to implement the item. This is the only transition that starts code-writing automation |
 | **Dev Implementation** | commits and pushes the agent's work, creates the PR, removes the worktree if `removeWorktreeAtState` says so |
-| **Needs Approval for Release** | requires the PR, sets its assignee (required — the approver of record) and any requested reviewers, removes the worktree if configured |
-| **Approved and Merged** | verifies you are the assignee, removes the metadata file, waits for the CI/CD suite, merges the PR — the merge is the approval — then deletes the branch and worktree |
+| **Needs Approval for Release** | requires the PR, sets its assignee (required — the approver of record) and any requested reviewers, removes a legacy workflow context file if the branch still carries one (its final commit), and removes the worktree if configured. From here on the branch stays as it is |
+| **Approved and Merged** | verifies you are the assignee, waits for the CI/CD suite, merges the PR as it stands — the merge is the approval — then deletes the branch and worktree |
 | Released | none — normally set by GitHub automation when the work merges to `main` |
 
-`start` begins state management, `next` advances one state, and `start-agent-implementation` jumps to Agent Implementation — all three reduce to the same engine, so branches and items always end up consistent with the state they are in.
+`start` begins state management, `next` advances one state, and `start-agent-implementation` jumps to Agent Implementation — all three reduce to the same engine, so branches and items always end up consistent with the state they are in. The engine and its layers are described in `src/workflow/README.md`.
 
 ### Who approves what
 
@@ -79,7 +83,7 @@ A change reaches production through two merges, and **each merge is its approval
 
 **Into `working/release`** — the PR's **assignee** (required) is its approver. They review the code and approve it by running `idea1 approve-pr`, which waits for the full CI/CD suite and then **merges** the PR. That is not the GitHub "Approve" button, which only leaves a review behind and merges nothing. A red or unfinished suite stops the merge, and there is no override at this stage. `approve-pr` checks that the person merging is the assignee; anyone else has to confirm explicitly, and the evidence report lists that merge as an exception. Requested reviewers are optional and record nothing. GitHub records the approval as `merged_by`, with its timestamp and merge commit.
 
-**Integration branches into `working/release`** — work items for an integration PR into `working/integration/<name>-main` and are approved there exactly as above. The integration branch itself enters `working/release` through `idea1 integrate`: it opens the PR with the approval chain of the work items it carries and assigns its approver; the assignee merges it (`idea1 integrate --pr-mode merge`) once the suite passes — the same sequence as a release, including the recorded admin override.
+**Any other branch into `working/release`** — a branch with no project item takes the same gate. `idea1 ready-for-approval` opens its PR (with the approval chain of what the branch carries as the body) and names its assignee; `idea1 approve-pr` merges it once the suite passes, with the same no-override rule, and then deletes the branch. Only the idea1.ai status writes are absent. Integration branches work this way: work items PR into `working/integration/<name>-main` and are approved there exactly as above, then the integration branch itself is carried into `working/release` with these two commands — its PR body lists every work-item PR and who approved it, and `approve-pr` refuses while any PR still targets the integration branch.
 
 **Into `main`** — `idea1 release` opens the release PR **assigned to whoever ran it**: the releaser is the approver, and their merge is the recorded approval. No review is required — every change in the release was already approved above, and the release PR body lists each contained PR with who approved it. What this stage gates is the build: the required CI/CD checks must pass first. In the default `create` mode the releaser merges the PR in GitHub once the checks are green; in `merge` mode the CLI waits for every check with `gh` and merges here. An emergency admin override past a red check needs an explicit confirmation and a stated reason, and is recorded as a comment on the PR before the merge.
 
@@ -87,7 +91,7 @@ This is the change-management control DataFabrIQ is audited on; see `infrastruct
 
 ### start
 
-Put a project item under workflow management. An item that has never been started enters **Build Spec in Progress**; an item that already has a state keeps it. The branch is created on origin from the base branch with the metadata file as its first commit — nothing is checked out, no code is written and Claude is not launched. Idempotent: running it again for a managed item just reports the branch and state.
+Put a project item under workflow management. An item yet to be started enters **Build Spec in Progress**; an item that already has a state keeps it. The branch is created on origin at the base branch's tip and recorded in the item's workflow context on idea1.ai; the working tree and the code stay as they are, and Claude stays closed. Idempotent: running it again for a managed item just reports the branch and state.
 
 ```bash
 idea1 start --url <url> [options]
@@ -96,8 +100,9 @@ idea1 s --url <url>
 ```
 
 **Options:**
-- `-u, --url <url>` - The Idea1.ai project item URL. Leave blank to create a new item (you'll be prompted for a `--title`).
+- `-u, --url <url>` - The Idea1.ai project item URL. Leave blank to create a new item (you'll be prompted for a `--title` and a `--project`).
 - `-t, --title <title>` - Title for the new project item (only when no URL is given).
+- `-P, --project <name>` - The Project to create the new item in, chosen from the team's live Projects (only when no URL is given; always asked, never defaulted).
 - `-p, --source-path <path>` - Path to source directory.
 - `-n, --branch-name <name>` - Branch name (auto-generated from the item description if not provided).
 - `-b, --base-branch <branch>` - Base branch / PR target (default: `working/release`).
@@ -107,7 +112,7 @@ idea1 s --url <url>
 
 Advance a project item to its next workflow state and run that state's automation. On the item's branch no arguments are needed; from anywhere else pass the item URL — the CLI finds the branch on origin (moving into its local checkout when one exists) or, for an item without a branch yet, reads the current state from idea1.ai and creates the branch first.
 
-With `--to <state>` the item advances through every state up to that one in a single run — the same as running `next` once per state, with each state's automation in order. The CLI only moves forward; an item already at or past the requested state is reported as an error.
+With `--to <state>` the item advances through every state up to that one in a single run — the same as running `next` once per state: each state's automation runs and the state is recorded on idea1.ai before the next state is entered. A run that stops part way leaves the item at the last state it entered, and running it again continues from there. The CLI only moves forward; an item already at or past the requested state is left as it is.
 
 ```bash
 idea1 next                        # on the item's branch
@@ -123,16 +128,16 @@ idea1 n
 - Any option of the state being entered (for example `--model`/`--effort` for Agent Implementation, `--assignee`/`--reviewers` for Needs Approval for Release). Options that were not supplied are prompted for when that state is reached.
 
 **What it does:**
-1. Syncs the branch's workflow state from origin (picking up changes made in the web client).
-2. Puts the item under workflow management if it is not yet (a never-started item enters Build Spec in Progress, which is the whole step).
-3. Runs the automation of every state entered, records the new state on the branch, in git config and on idea1.ai.
+1. Reads the item's workflow context from idea1.ai (picking up changes made in the web client) and fast-forwards the local checkout to origin when it is behind.
+2. Puts the item under workflow management when it is outside it yet (an item yet to be started enters Build Spec in Progress, which is the whole step).
+3. Runs the automation of every state entered and records the new state on idea1.ai.
 4. Reports "Workflow is complete" at `Released`.
 
 The automation is idempotent, so re-running a transition after the item was moved back in the web client does not repeat work that is already done: an existing PR is reused, an already-merged PR is left alone and the item simply moves on.
 
 ### start-agent-implementation
 
-Start implementing a project item: put it under workflow management if needed, move it to **Agent Implementation** (through any intermediate states, which have no automation), set up the working environment and launch Claude Code with the implementation prompt (or a prompt you supply — see `--entry-point-prompt`). This is the command behind "Send for Implementation" in the web client; `start-project-item` remains an alias so existing team command templates keep working.
+Start implementing a project item: put it under workflow management if needed, move it to **Agent Implementation** (through any intermediate states, which have no automation), set up the working environment and launch Claude Code with the implementation prompt — the repository's `prompts.agentImplementation` setting (see [Prompts](#prompts)), the built-in default, or a prompt you supply with `--entry-point-prompt`. This is the command behind "Send for Implementation" in the web client; `start-project-item` remains an alias so existing team command templates keep working.
 
 ```bash
 idea1 start-agent-implementation --url <url> [options]
@@ -147,8 +152,8 @@ idea1 implement --url <url> --entry-point-prompt "Read the spec in docs/spec.md
 - `-m, --model <model>` - Claude model for the implementation session (default: `opus`). Valid values: `fable`, `opus`, `sonnet`, `haiku`
 - `-e, --effort <level>` - Claude effort level (default: `high`). Valid values: `low`, `medium`, `high`, `xhigh`, `max`
 - `-im, --claude-entry-point <mode>` - How Claude is invoked once the environment is ready (default: `launch`). Valid values: `launch` (start a new Claude session), `inline` (output a structured prompt for an already-running Claude session), `none` (do not invoke Claude)
-- `-udp, --use-default-prompt <yes|no>` - Whether to launch Claude with the default implementation prompt (default: `yes`). Answering `no` asks for the prompt to use instead.
-- `-epp, --entry-point-prompt <prompt>` - The prompt to launch Claude with, replacing the default implementation prompt. Supplying it skips the "Use default prompt?" question.
+- `-udp, --use-default-prompt <yes|no>` - Whether to launch Claude with the repository's implementation prompt, or the built-in one when the repository sets none (default: `yes`). Answering `no` asks for the prompt to use instead.
+- `-epp, --entry-point-prompt <prompt>` - The prompt to launch Claude with, replacing the implementation prompt. Supplying it skips the "Use default prompt?" question. It is a Handlebars template like the repository's prompt, so it can use the same [variables](#prompts).
 
 An item already in Agent Implementation is not transitioned again: the working environment is set up (or reused) and Claude is launched.
 
@@ -178,12 +183,11 @@ idea1 j --branch-name <branch>
 - `--pull-request-url <url>` - A GitHub PR URL; its head branch is joined.
 - `-p, --source-path <path>` - Path to source directory.
 - `-iso, --isolation <mode>` - Where to work on the branch (default: `worktree`). See [Isolation mode](#isolation-mode).
-- `-pm, --permission-mode <mode>`, `-m, --model <model>`, `-e, --effort <level>` - Claude session settings recorded for the environment (defaults: `plan`, `opus`, `high`).
 
 **What it does:**
-1. Resolves the branch from the URL (or the URL from the branch) using the committed branch metadata.
+1. Resolves the branch from the URL (or the URL from the branch) through the item's workflow context on idea1.ai.
 2. Reuses the checkout that already holds the branch, or sets one up — a git worktree, or the branch checked out in the main repository (creating a local tracking branch if it only exists on origin).
-3. Syncs the workflow state from the metadata committed on origin into local git config, defaulting a legacy branch with no recorded state to `Agent Implementation`, and pushes any recovered metadata back to origin.
+3. Reports the item the branch implements and its state. A branch outside workflow management is joined as plain git work; `attach-project-item` puts it under workflow.
 4. Runs any setup hooks defined in `.idea1/settings.json` (newly created worktrees only).
 
 If a project item URL is supplied but no branch exists for it yet, `join-project-item` puts the item under workflow management first (as `start` does) and then sets up the environment.
@@ -206,14 +210,14 @@ idea1 a --url <url>
 - `-w, --workflow-type <type>` - Development workflow type: `independent` or `integration`. You also choose any stack branch and (for integration) the integration branch.
 
 **What it does:**
-1. Verifies the current branch is not already attached to a project item (errors if it is — use `join-project-item` to resume instead).
-2. Creates the project item if no URL was supplied, and reads its current workflow state from idea1.ai.
-3. Records the per-branch metadata (project item URL, base branch, workflow state, dev workflow type, stack/integration branch) in git config and the committed `.idea1/<branch>.json` file, and pushes the branch.
-4. Records the branch on the idea1.ai item. If the item is already at `Dev Implementation` or later, makes sure a PR into the base branch exists.
+1. Verifies the current branch is free to implement the item (a branch that already implements one is resumed with `join-project-item`).
+2. Creates the project item if no URL was supplied.
+3. Records the branch in the item's workflow context on idea1.ai (base branch, dev workflow type, stack/integration branch) in a single call, which puts an item outside workflow management under it at `Build Spec in Progress` and leaves an item that already has a state at that state. The branch is pushed to origin beforehand and stays as it is.
+4. If the item is already at `Dev Implementation` or later, makes sure a PR into the base branch exists.
 
 ### start-dev-implementation
 
-Enter **Dev Implementation** from Agent Implementation — the same step `next` takes from that state.
+Advance the item to **Dev Implementation** — the same as `next --to "Dev Implementation"`. From Agent Implementation that is one step; from an earlier state every state in between is entered first, each with its own automation. An item already at or past Dev Implementation is left as it is.
 
 ```bash
 idea1 start-dev-implementation [options]
@@ -224,68 +228,68 @@ idea1 dev [options]
 - `-p, --source-path <path>` - Path to worktree directory
 
 **What it does:**
-1. Validates the current state is "Agent Implementation" (after syncing from origin)
+1. Enters every state before Dev Implementation the item has yet to reach (after syncing from origin)
 2. Commits and pushes all changes in the branch
 3. Creates a PR of the branch into its base branch
-4. Records "Dev Implementation" in the branch metadata, git config and on Idea1.ai
+4. Records "Dev Implementation" on Idea1.ai
 5. If in a worktree and `removeWorktreeAtState` is `Dev Implementation`, removes the worktree. The main repo stays on its current branch; use `join-project-item` to work on the item in the main repo or a new worktree.
 
 ### ready-for-approval
 
-Enter **Needs Approval for Release** from Dev Implementation — the same step `next` takes from that state. Its job is to name the **assignee**, who will approve the change by merging it.
+On a project item's branch, advance the item to **Needs Approval for Release** — the same as `next --to "Needs Approval for Release"`: from an earlier state, every state in between is entered first, each with its own automation (PR creation on the way into Dev Implementation, for one), and an item already at or past it is left as it is. On any other branch (an integration branch, a branch with no project item), open the branch's PR into the base branch when it has none. Either way its job is to name the **assignee**, who will approve the change by merging it.
 
 ```bash
 idea1 ready-for-approval [options]
 idea1 rfa --assignee octocat
+idea1 rfa --assignee octocat                       # on working/integration/<name>-main: opens the PR into working/release
+idea1 rfa --assignee octocat -b working/release    # a branch with no project item, naming the PR target
 ```
 
 **Options:**
 - `-a, --assignee <username>` - **Required.** Who approves the PR by merging it (prompted from the repository's assignable users when omitted)
 - `-r, --reviewers <user1,user2>` - Who to request a review from (multi-select when omitted). Optional, and separate from approval — the assignee is the approver
+- `-b, --base-branch <branch>` - Branches with no project item only: the branch the PR targets (default: the open PR's base, else `baseBranch`, then `working/release`)
+- `--title <title>` - Branches with no project item only: PR title when the PR has to be created (default: `Integration <name> <YYYY-MM-DD>` for an integration branch, else the branch name; prompted when omitted)
 
-**What it does:**
-1. Validates the current state is "Dev Implementation" (after syncing from origin)
+**What it does on a project item's branch:**
+1. Enters every state before Needs Approval for Release the item has yet to reach (after syncing from origin)
 2. Ensures no uncommitted or unpushed changes in the local checkout
 3. Requires the PR to exist, then sets the assignee (the transition refuses to proceed without one) and requests any reviewers
-4. Records "Needs Approval for Release" in the branch metadata, git config and on Idea1.ai
-5. If in a worktree and `removeWorktreeAtState` is `Needs Approval for Release` (the default) or earlier, removes the worktree
+4. Legacy branches only: removes the `.idea1/<branch>.json` workflow context file the branch still carries and pushes — the branch's final commit, so the CI/CD suite runs once more on exactly what will merge and the target branch receives the work alone
+5. Records "Needs Approval for Release" on Idea1.ai. From here on the branch stays as it is
+6. If in a worktree and `removeWorktreeAtState` is `Needs Approval for Release` (the default) or earlier, removes the worktree
+
+**What it does on a branch with no project item:**
+1. Requires you to be on the branch with nothing uncommitted, unpushed or behind origin; refuses on the base branch itself and refuses a PR straight into `main` (that is `idea1 release`)
+2. Reuses the branch's open PR (and its base) when one exists; otherwise creates the PR into the base branch with the approval chain of what the branch carries as its body — every PR merged into the branch with its author and approver, and commits pushed straight to the branch listed as the change under review (they are not an exception: this PR is their stage-1 approval)
+3. Sets the assignee and requests any reviewers
+4. Records no workflow status — there is no project item
 
 ### approve-pr
 
-Enter **Approved and Merged** from Needs Approval for Release — the same step `next` takes from that state. Run by the PR's **assignee**: it waits for the CI/CD suite and merges the PR, and that merge is the approval of record.
+On a project item's branch, advance the item to **Approved and Merged** — the same as `next --to "Approved and Merged"`: from an earlier state, every state in between is entered first, each with its own automation, and an item already at or past it is left as it is. On any other branch, merge the branch's PR. Run by the PR's **assignee**: it waits for the CI/CD suite and merges the PR, and that merge is the approval of record. There is no admin override at this stage for any branch.
 
 ```bash
 idea1 approve-pr
 idea1 approve
+idea1 approve-pr --branch working/integration/<name>-main   # from anywhere: the branch need not be checked out
 ```
 
-**What it does:**
-1. Validates the current state is "Needs Approval for Release" (after syncing from origin)
+**Options:**
+- `-b, --branch <branch>` - Branch whose PR to approve (default: the current branch). A project item's branch is approved through the workflow; any other branch through its PR alone
+
+**What it does on a project item's branch:**
+1. Enters every state before Approved and Merged the item has yet to reach (after syncing from origin)
 2. Verifies the approver: refuses when the PR has no assignee, and when you are not the assignee warns that the merge record will name you instead and requires an explicit confirmation (the evidence report lists such a merge as an exception)
-3. Removes the branch's `.idea1/<branch>.json` so it does not leak into the target branch, waits for the required CI/CD checks on the PR (that push re-runs the suite), then merges the PR. A red or unfinished suite stops the merge — there is no admin override at this stage
-4. Records "Approved and Merged" in git config and on Idea1.ai
+3. Waits for the required CI/CD checks on the PR — the checks of the branch's tip on origin, which the PR must have picked up first — then merges the PR. A red or unfinished suite stops the merge — there is no admin override at this stage. The branch is merged as it stands. A legacy branch that still carries its workflow context file has the file removed and pushed instead, and the approval is left for a second run once the re-run suite passes
+4. Records "Approved and Merged" on Idea1.ai
 5. Switches to the base branch and deletes the feature branch. If still running inside a worktree, removes the worktree instead of switching branches — this always happens, since the base branch can't be checked out in place there
 
-### integrate
-
-Carry an integration branch (`working/integration/<name>-main`) into the release branch. This is stage 1 for integration work: the work items were each approved on their own PR into the integration branch; `integrate` opens the integration branch's PR into `working/release`, assigns its approver, and — run by that assignee — merges it once the required CI/CD checks pass. It is not part of the project-item state machine.
-
-```bash
-idea1 integrate --assignee octocat        # on the integration branch: open the PR and assign its approver
-idea1 integrate --pr-mode merge           # run by the assignee: wait for the checks, then merge
-idea1 int
-```
-
-**Options:**
-- `-b, --branch <branch>` - Integration branch to integrate (default: the current branch when it is one, otherwise a pick from the integration branches on origin)
-- `-t, --target <branch>` - Branch to integrate into (default: `baseBranch`, then `working/release`)
-- `-a, --assignee <username>` - Who approves the integration by merging its PR (prompted when the PR is created and none is given)
-- `-pr, --pr-mode <mode>` - `create` (default) opens the PR in the browser to merge there once the checks pass; `merge` waits for every check with `gh` and merges here
-- `--title <title>` - PR title (default: `Integration <name> <YYYY-MM-DD>`)
-
-**What it does:**
-1. Reuses the open PR from the integration branch into the target if one exists; otherwise requires you to be on the integration branch with nothing uncommitted, unpushed or behind origin, and creates the PR assigned to the approver, with the approval chain of the work-item PRs it carries as its body
-2. In `merge` mode, checks that you are the assignee (anyone else must confirm explicitly), waits for the required CI/CD checks and merges. Checks that fail, never start or never finish stop the merge; the admin override takes an explicit confirmation and a required reason, and the exception is recorded as a comment on the PR before anything is merged
+**What it does on a branch with no project item:**
+1. Finds the branch's PR (run `ready-for-approval` first if there is none) and takes the target branch from it
+2. Refuses while any open PR still targets the branch — merging would retire the branch and orphan them
+3. Verifies the approver exactly as above, waits for the required CI/CD checks and merges. A red or unfinished suite stops the merge — no override
+4. Deletes the branch on origin and locally (removing its worktree, or switching to the base branch first when it is checked out in the main repo). Records no workflow status
 
 ### release
 
@@ -333,6 +337,9 @@ Create `.idea1/settings.json` in your repository root to configure repo-specific
   "hooks": {
     "setup-worktree": "dev/workflow/setup-worktree.sh"
   },
+  "prompts": {
+    "agentImplementation": "Implement {{projectItemUrl}} on {{branchName}}."
+  },
   "defaults": {
     "branchPrefix": "working/agent",
     "baseBranch": "working/release",
@@ -344,6 +351,9 @@ Create `.idea1/settings.json` in your repository root to configure repo-specific
 **Hooks:**
 - `setup-worktree` - Script to run after creating a new worktree (e.g., install dependencies)
 
+**Prompts:**
+- `agentImplementation` - The prompt an Agent Implementation session starts with. See [Prompts](#prompts).
+
 **Defaults:**
 - `branchPrefix` - Prefix for new branches (default: `working/agent`)
 - `baseBranch` - Default base branch for branching (default: `working/release`)
@@ -355,8 +365,8 @@ Create `.idea1/settings.json` in your repository root to configure repo-specific
 `.idea1/settings.local.json` is an optional, git-ignored file with the same shape as
 `settings.json`. Anything it defines overrides the committed settings for that clone
 only, which keeps developer-specific preferences out of the shared configuration.
-`hooks` and `defaults` are merged section by section, so overriding one value leaves
-the rest of the committed settings in place.
+`hooks`, `prompts` and `defaults` are merged section by section, so overriding one value
+leaves the rest of the committed settings in place.
 
 ```json
 {
@@ -366,6 +376,56 @@ the rest of the committed settings in place.
 }
 ```
 
+### Prompts
+
+Every prompt the CLI gives Claude is a [Handlebars](https://handlebarsjs.com/) template
+rendered against a data model, so a repository can replace a prompt with its own template
+using the full Handlebars syntax (`{{#if}}`, `{{#each}}`, `{{else}}`, ...).
+
+`prompts.agentImplementation` is the prompt an Agent Implementation session starts with
+(`start-agent-implementation`, or `next` entering Agent Implementation). It is either the
+template itself or the file that holds it, relative to the repository root:
+
+```json
+{
+  "prompts": {
+    "agentImplementation": "/df-implement-project-item {{projectItemUrl}}"
+  }
+}
+```
+
+```json
+{
+  "prompts": {
+    "agentImplementation": { "templateFile": ".idea1/prompts/agent-implementation.md" }
+  }
+}
+```
+
+Without the setting, the built-in prompt asks Claude to implement the item from its Idea1
+context. `--entry-point-prompt` replaces both for one session and is rendered the same way.
+The settings are read from the main repository, so an override in its
+`settings.local.json` applies in worktrees too.
+
+The template renders against the item and its branch:
+
+| Variable | Value |
+|----------|-------|
+| `projectItemUrl` | The project item's URL |
+| `workflowStatus` | The item's workflow state (`Agent Implementation`) |
+| `repositoryFullName` | The repository, as `owner/name` |
+| `branchName` | The item's branch |
+| `baseBranch` | The branch the item's PR targets (the integration branch for integration work) |
+| `devWorkflowType` | `independent` or `integration` |
+| `stackBranch` | The branch this one is stacked on, or null |
+| `integrationBranch` | The integration branch, or null for independent work |
+| `pullRequestUrl` | The item's PR, or empty when there is none yet |
+| `workingPath` | The directory the branch is checked out in |
+
+Rendering is strict: a template that outputs a variable not in this list fails with an error
+rather than rendering it empty. Test a null variable with `{{#if}}` before outputting it, e.g.
+`{{#if stackBranch}}Stacked on {{stackBranch}}.{{/if}}`.
+
 ### Worktree Removal
 
 When work happens in a git worktree, `removeWorktreeAtState` decides which workflow
@@ -395,6 +455,12 @@ Settings include:
 Branch names are not user settings: they belong to the repository and are read from
 its `.idea1/settings.json`.
 
+## How the CLI uses Claude
+
+Every use of Claude Code goes through `src/services/claude.ts`, the only module that spawns `claude`. It always passes `--model` and `--effort`: a caller that states neither gets the documented defaults (`opus`, `high` — the same defaults the implementation session offers), so a run never inherits whatever was last picked in an interactive session.
+
+Access to the Idea1 cloud platform — reading a project item's summary (by item or by the branch it implements), recording the item's workflow context, setting its workflow status, creating items, listing Projects, generating a branch name — goes through `src/services/platform.ts`. Its prompts are Handlebars templates in `src/prompts/`, rendered by `src/services/template-renderer.ts` like every other prompt. Today it drives the Idea1 MCP tools through Claude on `sonnet` at `medium` effort (these are simple tool calls, not implementation sessions); that transport is the module's implementation detail and may become direct calls to the platform API. The implementation session launched on entering Agent Implementation is the one place the model and effort are the user's choice (`--model`, `--effort`).
+
 ## Requirements
 
 - Node.js 20+

package/dist/cli/named-lists.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"named-lists.d.ts","sourceRoot":"","sources":["../../src/cli/named-lists.ts"],"names":[],"mappings":"AAqBA;;;GAGG;AACH,wBAAsB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,KAAK,CAAC;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC,CAYrG"}
+{"version":3,"file":"named-lists.d.ts","sourceRoot":"","sources":["../../src/cli/named-lists.ts"],"names":[],"mappings":"AA0BA;;;GAGG;AACH,wBAAsB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,KAAK,CAAC;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC,CAYrG"}

package/dist/cli/named-lists.js

@@ -1,4 +1,5 @@
 import * as github from '../services/github.js';
+import * as platform from '../services/platform.js';
 /**
  * Registry of named choice lists. Options reference these by name via
  * CommandOption.choices, letting multiple options share the same
@@ -8,6 +9,10 @@ const registry = {
     'github-members': async () => {
         const logins = await github.listAssignableUsers();
         return logins.map(login => ({ label: login, value: login }));
+    },
+    'idea1-projects': async () => {
+        const projects = await platform.listProjects();
+        return projects.map(name => ({ label: name, value: name }));
     }
 };
 /**

package/dist/cli/named-lists.js.map

@@ -1 +1 @@
-{"version":3,"file":"named-lists.js","sourceRoot":"","sources":["../../src/cli/named-lists.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,uBAAuB,CAAC;AAShD;;;;GAIG;AACH,MAAM,QAAQ,GAAmC;IAC/C,gBAAgB,EAAE,KAAK,IAAI,EAAE;QAC3B,MAAM,MAAM,GAAG,MAAM,MAAM,CAAC,mBAAmB,EAAE,CAAC;QAClD,OAAO,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC;IAC/D,CAAC;CACF,CAAC;AAEF;;;GAGG;AACH,MAAM,CAAC,KAAK,UAAU,gBAAgB,CAAC,IAAY;IACjD,MAAM,QAAQ,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAC;IAChC,IAAI,CAAC,QAAQ,EAAE,CAAC;QACd,MAAM,IAAI,KAAK,CAAC,yBAAyB,IAAI,GAAG,CAAC,CAAC;IACpD,CAAC;IAED,MAAM,OAAO,GAAG,MAAM,QAAQ,EAAE,CAAC;IACjC,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACzB,MAAM,IAAI,KAAK,CAAC,gBAAgB,IAAI,uBAAuB,CAAC,CAAC;IAC/D,CAAC;IAED,OAAO,OAAO,CAAC;AACjB,CAAC"}
+{"version":3,"file":"named-lists.js","sourceRoot":"","sources":["../../src/cli/named-lists.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,uBAAuB,CAAC;AAChD,OAAO,KAAK,QAAQ,MAAM,yBAAyB,CAAC;AASpD;;;;GAIG;AACH,MAAM,QAAQ,GAAmC;IAC/C,gBAAgB,EAAE,KAAK,IAAI,EAAE;QAC3B,MAAM,MAAM,GAAG,MAAM,MAAM,CAAC,mBAAmB,EAAE,CAAC;QAClD,OAAO,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC;IAC/D,CAAC;IACD,gBAAgB,EAAE,KAAK,IAAI,EAAE;QAC3B,MAAM,QAAQ,GAAG,MAAM,QAAQ,CAAC,YAAY,EAAE,CAAC;QAC/C,OAAO,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC;IAC9D,CAAC;CACF,CAAC;AAEF;;;GAGG;AACH,MAAM,CAAC,KAAK,UAAU,gBAAgB,CAAC,IAAY;IACjD,MAAM,QAAQ,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAC;IAChC,IAAI,CAAC,QAAQ,EAAE,CAAC;QACd,MAAM,IAAI,KAAK,CAAC,yBAAyB,IAAI,GAAG,CAAC,CAAC;IACpD,CAAC;IAED,MAAM,OAAO,GAAG,MAAM,QAAQ,EAAE,CAAC;IACjC,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACzB,MAAM,IAAI,KAAK,CAAC,gBAAgB,IAAI,uBAAuB,CAAC,CAAC;IAC/D,CAAC;IAED,OAAO,OAAO,CAAC;AACjB,CAAC"}

package/dist/commands/approve-pr.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"approve-pr.d.ts","sourceRoot":"","sources":["../../src/commands/approve-pr.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAKjD,eAAO,MAAM,gBAAgB,EAAE,OAW9B,CAAC"}
+{"version":3,"file":"approve-pr.d.ts","sourceRoot":"","sources":["../../src/commands/approve-pr.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAuFjD,eAAO,MAAM,gBAAgB,EAAE,OAuC9B,CAAC"}

package/dist/commands/approve-pr.js

@@ -1,15 +1,101 @@
-import { WorkflowStates } from '../lib/workflow-states.js';
-import { advanceTo, requireCurrentState, resolveContext } from '../services/workflow-engine.js';
-import { approvePrHandler } from '../services/workflow-handlers/approve-pr.js';
+import { logger } from '../lib/logger.js';
+import { readBranchSettings } from '../lib/settings.js';
+import * as git from '../services/git.js';
+import * as github from '../services/github.js';
+import * as worktree from '../services/worktree.js';
+import { WorkflowStates } from '../workflow/data/workflow-states.js';
+import { cleanUpMergedBranch, mergeAsApprover } from '../workflow/engine/approval-flow.js';
+import { confirmApproverIdentity } from '../workflow/engine/release-flow.js';
+import { advanceAsNeededTo, getProjectItemSummaryForBranch, resolveTransition, resolveTransitionIfManaged } from '../workflow/engine/workflow-engine.js';
+import { deferredHandlerOptions } from '../workflow/engine/handlers/index.js';
+/**
+ * Stage 1 approval for a branch with no project item: the assignee merges the branch's PR once
+ * the required checks pass (no override), then the branch is cleaned up. No workflow status is
+ * recorded. The branch need not be checked out - the assignee can approve from anywhere.
+ */
+async function approvePrOnBranchWithNoItem(branchName) {
+    await github.ensureGitHubCli();
+    // Captured before anything moves: cleanup may switch branches or remove a worktree.
+    const workingPath = await git.getCheckoutPathForBranch(branchName);
+    const isCurrentBranch = (await git.getCurrentBranch()) === branchName;
+    const prInfo = await github.getPrInfo(branchName);
+    if (!prInfo) {
+        throw new Error('No PR found for this branch. Run idea1 ready-for-approval first to open it and name its approver.');
+    }
+    logger.info(`PR #${prInfo.number} found`);
+    const state = prInfo.state.toUpperCase();
+    if (state === 'CLOSED') {
+        throw new Error(`PR #${prInfo.number} is closed without being merged; there is nothing to approve.`);
+    }
+    const baseBranch = prInfo.baseRefName ?? await worktree.resolveBaseBranch();
+    const releaseTargetBranch = (await readBranchSettings(await git.getRepoRoot())).releaseTargetBranch;
+    if (baseBranch === releaseTargetBranch) {
+        throw new Error(`PR #${prInfo.number} targets ${releaseTargetBranch}: that is a release, not a change to approve. ` +
+            'Use idea1 release for it (change-management-policy.md clause 2).');
+    }
+    logger.header(`Approve: ${branchName} -> ${baseBranch}`);
+    logger.info('This branch has no project item, so no workflow status is recorded.');
+    logger.newline();
+    if (state === 'MERGED') {
+        logger.dim(`PR #${prInfo.number} is already merged; cleaning up the branch.`);
+    }
+    else {
+        if (isCurrentBranch) {
+            await git.ensureBranchUpToDate();
+        }
+        // Merging retires the branch, which would orphan any PR still targeting it.
+        const openPrsInto = await github.listOpenPrsInto(branchName);
+        if (openPrsInto.length > 0) {
+            const list = openPrsInto.map(pr => `  #${pr.number}  ${pr.headRefName}  ${pr.title}`).join('\n');
+            throw new Error(`${openPrsInto.length} open PR(s) still target ${branchName}; approve or close them before approving this branch:\n${list}`);
+        }
+        await confirmApproverIdentity(branchName);
+        await mergeAsApprover({ branchName, baseBranch, prNumber: prInfo.number });
+    }
+    await cleanUpMergedBranch({ branchName, baseBranch, workingPath });
+    logger.newline();
+    logger.success(`PR merged into ${baseBranch} - the merge is the recorded approval`);
+}
+/**
+ * The transition for a named branch when it is a project item's branch, else null.
+ */
+async function resolveTransitionForNamedBranch(branchName, resolved) {
+    const projectItemUrl = (await getProjectItemSummaryForBranch(branchName))?.url ?? null;
+    return projectItemUrl ? resolveTransition({ projectItemUrl, options: resolved }) : null;
+}
 export const approvePrCommand = {
     name: 'approve-pr',
     aliases: ['approve'],
-    description: 'Approve the PR by merging it (the assignee runs this), completing the workflow',
-    options: approvePrHandler.options,
+    description: 'Approve the PR by merging it (the assignee runs this) - on a project item\'s branch (advancing the item through every state before it) or any other branch',
+    options: [
+        {
+            longName: 'branch',
+            shortName: 'b',
+            description: 'Branch whose PR to approve (default: the current branch)',
+            defaultValue: '',
+            promptWhenDefaultExists: false
+        },
+        // On a project item's branch the item may be further back; the states it passes through on the
+        // way (the assignee of Needs Approval for Release, for one) ask for their own options.
+        ...deferredHandlerOptions([])
+    ],
     async execute(resolved) {
-        const context = await resolveContext({ options: resolved });
-        requireCurrentState(context, WorkflowStates.NeedsApprovalForRelease, 'approve-pr');
-        await advanceTo(context, WorkflowStates.ApprovedAndMerged);
+        const requestedBranch = resolved['branch'] || null;
+        // A named branch the platform records as an item's is approved through
+        // the workflow engine, from wherever the command is run. With no branch named, the current
+        // branch is the target, managed or not.
+        const transition = requestedBranch
+            ? await resolveTransitionForNamedBranch(requestedBranch, resolved)
+            : await resolveTransitionIfManaged({ options: resolved });
+        if (transition) {
+            await advanceAsNeededTo(transition, WorkflowStates.ApprovedAndMerged);
+            return;
+        }
+        const branchName = requestedBranch ?? await git.getCurrentBranch();
+        if (branchName === 'HEAD') {
+            throw new Error('You are not on a branch (detached HEAD). Check out the branch to approve, or pass --branch <name>.');
+        }
+        await approvePrOnBranchWithNoItem(branchName);
     }
 };
 //# sourceMappingURL=approve-pr.js.map

package/dist/commands/approve-pr.js.map

@@ -1 +1 @@
-{"version":3,"file":"approve-pr.js","sourceRoot":"","sources":["../../src/commands/approve-pr.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAC3D,OAAO,EAAE,SAAS,EAAE,mBAAmB,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAC;AAChG,OAAO,EAAE,gBAAgB,EAAE,MAAM,6CAA6C,CAAC;AAE/E,MAAM,CAAC,MAAM,gBAAgB,GAAY;IACvC,IAAI,EAAE,YAAY;IAClB,OAAO,EAAE,CAAC,SAAS,CAAC;IACpB,WAAW,EAAE,gFAAgF;IAC7F,OAAO,EAAE,gBAAgB,CAAC,OAAO;IAEjC,KAAK,CAAC,OAAO,CAAC,QAAgC;QAC5C,MAAM,OAAO,GAAG,MAAM,cAAc,CAAC,EAAE,OAAO,EAAE,QAAQ,EAAE,CAAC,CAAC;QAC5D,mBAAmB,CAAC,OAAO,EAAE,cAAc,CAAC,uBAAuB,EAAE,YAAY,CAAC,CAAC;QACnF,MAAM,SAAS,CAAC,OAAO,EAAE,cAAc,CAAC,iBAAiB,CAAC,CAAC;IAC7D,CAAC;CACF,CAAC"}
+{"version":3,"file":"approve-pr.js","sourceRoot":"","sources":["../../src/commands/approve-pr.ts"],"names":[],"mappings":"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"}

package/dist/commands/attach-project-item.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"attach-project-item.d.ts","sourceRoot":"","sources":["../../src/commands/attach-project-item.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AASjD,eAAO,MAAM,wBAAwB,EAAE,OAwFtC,CAAC"}
+{"version":3,"file":"attach-project-item.d.ts","sourceRoot":"","sources":["../../src/commands/attach-project-item.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AASjD,eAAO,MAAM,wBAAwB,EAAE,OA2FtC,CAAC"}