breakaway 1.4.0-main.38 → 1.4.0-main.4

package/.agents/skills/tasks/SKILL.md

@@ -31,7 +31,6 @@ breakaway's work is on the board that tracks this repository. The CLI is `npx br
 | You need the owner to choose | Ask with a decision, not prose: `add "<title>" --tag owner --decision <file.json>` and make the work that waits `--depends` on it. Only the owner answers, on the board; read the answers with `show`. |
 | Part of the work needs the owner (an install, a dashboard, a sign-off) | Finish your part, then `add` a `+owner` task for the rest that `--depends` on yours. |
 | Task needs design choices | Write the spec in `docs/specs/<ID>-<slug>.md` and `modify <ID> --spec <path>`. |
-| Reading the repository's specs | `tasks specs` lists them, newest first, with each one's status and its tasks; `specs show <path>` prints one with the tasks that link it. They're read from GitHub's default branch, so a spec still in a pull request isn't there yet. |
 | You're blocked by another task | `comment` why, `release`, and pick the blocker or another task. |
 | A claim looks abandoned | Ask the owner; don't take it. |
 | Opening a pull request for a spec, plan, or partial step | Write `Part of <ID>.`, not `Closes`, and don't put it in `--pr`: merging the pull request in that field finishes the task. A branch name alone never closes anything. |
@@ -39,7 +38,6 @@ breakaway's work is on the board that tracks this repository. The CLI is `npx br
 | `claim` says the task belongs to another repository | Don't cross it with `--repo`: that work belongs in a checkout of its own repository. `comment` and `release` if the board started you on it. |
 | The board started you | Follow [`prompts/breakaway.md`](../../../prompts/breakaway.md), which starts with the core. Check the payload's `Repository:` line against `git remote get-url origin` first. |
 | The task is an `IDEA-` | Shape it, don't build it: "Shaping an idea" in the core. |
-| The board started you on a kickoff (`Mode: kickoff`) | Interview the owner first: ask plain questions as a decision on the IDEA (at most 12, then at most 6 more if something important is open), `release`, and stop; once they're answered, shape it with `AGENTS.md`, the prompt's sections, an **In short**, and a `<slug>-v1` feature. "Kicking off a project" in the core. |
 | The board started you from the owner's prompt (`Mode: general`) | Give the task an area first (`modify <ID> --project <area>` gives it its work ID), retitle it, and take the smallest path: a pull request, board edits noted on each task, a spec, a task in another repository, or a decision or ping. Releasing it with no pull request closes it. "Running a general agent" in the core. |
 | The board started you to review a pull request (`Mode: pr-review`) | Test it and read it against the task; answer with `review <ID> --verdict ready\|follow-up\|changes "<note>"` and `release`. Never push or merge. "Reviewing a pull request" in the core. |
 | Only the owner can help, or the task is already done or won't reproduce | `ping <ID> --kind blocked\|question\|stale\|done "<message>"`, then `release`. Ping only when the owner must act or would want to know now, never for progress. Full rules: "Pinging the owner" in the core. |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "breakaway",
-  "version": "1.4.0-main.38",
+  "version": "1.4.0-main.4",
   "description": "The task board for you and your coding agents: a Cloudflare Worker, its web app, Taskwarrior sync, and the CLI (npx breakaway).",
   "license": "FSL-1.1-Apache-2.0",
   "type": "module",
@@ -21,21 +21,17 @@
     "!scripts/install/*.test.js",
     "src/cli-version.js",
     "src/decision.js",
-    "src/init.js",
     "src/install.js",
     "src/model.js",
-    "src/packages.js",
     "src/ping.js",
     "src/promote.js",
     "src/prompt.js",
     "src/redact.js",
     "src/repos.js",
-    "src/specs.js",
     "src/versions.js",
     "prompts/*.md",
     "taskrc",
     ".agents/skills/tasks/SKILL.md",
-    ".agents/skills/pipeline/SKILL.md",
     "template"
   ],
   "engines": {
@@ -51,16 +47,15 @@
   },
   "scripts": {
     "dev": "vite",
-    "prepare": "node scripts/board-files.mjs",
-    "build": "node scripts/board-files.mjs && vite build",
-    "test": "node scripts/board-files.mjs && vitest run && vitest run --config scripts/tasks/vitest.config.js",
+    "build": "vite build",
+    "test": "vitest run && vitest run --config scripts/tasks/vitest.config.js",
     "brand": "node scripts/brand-lint.mjs",
     "format": "biome format --write .",
     "lint": "biome check .",
-    "typecheck": "node scripts/board-files.mjs && wrangler types && tsc -p tsconfig.json && tsc -p scripts/tsconfig.json && tsc -p web/tsconfig.json",
+    "typecheck": "wrangler types && tsc -p tsconfig.json && tsc -p scripts/tsconfig.json && tsc -p web/tsconfig.json",
     "site": "node site/build.mjs",
     "interop": "node interop.mjs",
-    "deploy": "node scripts/board-files.mjs && vite build && wrangler deploy -c wrangler.jsonc"
+    "deploy": "vite build && wrangler deploy -c wrangler.jsonc"
   },
   "devDependencies": {
     "@biomejs/biome": "2.5.15",

package/prompts/breakaway.md

@@ -2,7 +2,7 @@ You are a breakaway agent, started by the task board to work on one task in brea
 
 This is breakaway's agent prompt. Your instructions have two parts, and you follow both:
 
-1. **The board's core, [`prompts/core.md`](core.md).** Read the whole file now, before anything else. It says how to work from the board in any repository: your assignment in the payload, checking you're in the right repository, claiming, the modes (shaping an idea, kicking off a project, refining, reviewing a Dependabot pull request, fixing a pull request, running a routine, running a general agent, reviewing a pull request), messages from the owner, the peloton, decisions, and pings.
+1. **The board's core, [`prompts/core.md`](core.md).** Read the whole file now, before anything else. It says how to work from the board in any repository: your assignment in the payload, checking you're in the right repository, claiming, the modes (shaping an idea, refining, reviewing a Dependabot pull request, fixing a pull request, running a routine, running a general agent, reviewing a pull request), messages from the owner, the peloton, decisions, and pings.
 2. **breakaway's own rules, below.** The core leaves what each step means in a repository to its prompt, under these headings. Where both say something, follow both; nothing here loosens a rule in the core.
 
 The routine on claude.ai holds only the stub, [`prompts/stub.md`](stub.md), which points here, so the copy in your checkout is always the current one.

package/prompts/core.md

@@ -16,7 +16,7 @@ How to work:
 
 1. **Check you're in the task's repository.** `git remote get-url origin` must end with the `owner/name` on the `Repository:` line (a cloud session's proxied remote ends the same way). If it doesn't, the routine that started you is saved with the wrong repository: change nothing, `comment <the task> "Started in <your checkout's owner/name>, but <the task> is <slug>'s (<owner/name>): its routine on claude.ai needs that repository."`, `release <the task>`, and stop. Don't claim it: `claim` refuses a task of another repository anyway, and never cross it with `--repo`.
 2. **Claim it.** Read the repository's `AGENTS.md`, then the `tasks` skill (`.agents/skills/tasks/SKILL.md`, or wherever the repository's prompt says). Run `export BREAKAWAY_AGENT=<your agent name>` and `tasks claim <the task>`. The board has already claimed it for you under that name, so this succeeds; if it doesn't, stop and explain why on the task with `comment`. If it warns that live output won't show on the task, comment that warning on the task and carry on.
-3. **Read it.** `tasks show <the task>`: its description and done when, its comments, its spec if it has one, and what it waits for and holds up. If it's tagged +decide, or it needs a decision only the owner can make, don't start it: if it has no questions yet, give it some (see "Asking for a decision" below), note what's needed, release it, and stop. If its work ID starts with `IDEA-`, it's an idea the owner wrote down, not work to build: check in (step 4), then do "Shaping an idea" below instead of steps 5 and 6, then watch the pull request as in step 8. If the payload has a `Mode: kickoff` line, the idea is a new project the owner kicked off from the board: do "Kicking off a project" below instead of steps 4 to 7 (it checks in before it writes anything), then watch the pull request as in step 8 if you opened one. If the payload has a `Mode: refine` line, the owner asked you to improve the task, not build it: do "Refining a task" below instead of steps 4 to 7 (it checks in only if it writes a spec), and only watch a pull request if you opened one. If the payload has a `Mode: review` line, the owner asked whether a Dependabot pull request is safe to merge: do "Reviewing a Dependabot pull request" below instead of steps 4 to 7. If the payload has a `Mode: fix-pr` line, the owner asked you to fix a pull request, not build the task: check in (step 4), then do "Fixing a pull request" below instead of steps 5 to 7, then watch it as in step 8. If the payload has a `Mode: routine` line, the task is one run of a routine the owner saved: check in (step 4), then do "Running a routine" below instead of steps 5 and 6, then open and watch the pull request as in steps 7 and 8. If the payload has a `Mode: general` line, the owner started you from a prompt, not a task: check in (step 4), then do "Running a general agent" below instead of steps 5 to 7, then watch the pull request as in step 8 if you opened one. If the payload has a `Mode: pr-review` line, the owner asked you to review a pull request before they merge it: do "Reviewing a pull request" below instead of steps 4 to 8. A payload without a `Mode:` line is a build.
+3. **Read it.** `tasks show <the task>`: its description and done when, its comments, its spec if it has one, and what it waits for and holds up. If it's tagged +decide, or it needs a decision only the owner can make, don't start it: if it has no questions yet, give it some (see "Asking for a decision" below), note what's needed, release it, and stop. If its work ID starts with `IDEA-`, it's an idea the owner wrote down, not work to build: check in (step 4), then do "Shaping an idea" below instead of steps 5 and 6, then watch the pull request as in step 8. If the payload has a `Mode: refine` line, the owner asked you to improve the task, not build it: do "Refining a task" below instead of steps 4 to 7 (it checks in only if it writes a spec), and only watch a pull request if you opened one. If the payload has a `Mode: review` line, the owner asked whether a Dependabot pull request is safe to merge: do "Reviewing a Dependabot pull request" below instead of steps 4 to 7. If the payload has a `Mode: fix-pr` line, the owner asked you to fix a pull request, not build the task: check in (step 4), then do "Fixing a pull request" below instead of steps 5 to 7, then watch it as in step 8. If the payload has a `Mode: routine` line, the task is one run of a routine the owner saved: check in (step 4), then do "Running a routine" below instead of steps 5 and 6, then open and watch the pull request as in steps 7 and 8. If the payload has a `Mode: general` line, the owner started you from a prompt, not a task: check in (step 4), then do "Running a general agent" below instead of steps 5 to 7, then watch the pull request as in step 8 if you opened one. If the payload has a `Mode: pr-review` line, the owner asked you to review a pull request before they merge it: do "Reviewing a pull request" below instead of steps 4 to 8. A payload without a `Mode:` line is a build.
 4. **Check in on the peloton, before any change.** Every mode that changes files does this step, and none skips it: a build, an idea, `fix-pr`, a routine, and a general agent. Once you know what you'll change, and before your first change, run `tasks peloton checkin "<what you'll change: the files or areas you'll touch>"`. It posts on your repository's peloton and, when your task is in an open chase, on the chase's too, so a chase agent checks in on both rooms. It prints who else is riding; if someone is on the same files, agree who goes first before you start. See "Riding the peloton" below.
 5. **Do the work** on your branch the way the repository's `AGENTS.md` and its prompt's **Building** say. Note what you learn on the task as you go. Add tasks for work you find instead of doing it too.
 6. **Before handing over**, the repository's **Checks** pass, and you've said on the peloton what the pull request changes.
@@ -46,22 +46,6 @@ The idea is the task's description, in the owner's own words. Never rewrite it:
 
 The pull request holds only the spec. The tasks already exist on the board, waiting for it to merge.
 
-## Kicking off a project (`Mode: kickoff` in the payload)
-
-The owner kicked off a new project from the board: the task is its `IDEA-`, tagged `+kickoff-project`, in a new repository that holds only the board's files. Its description is the owner's pitch, in their own words: never rewrite it. The owner may not be technical, so you interview them in plain words first, then plan. Each run does one of two things, and the IDEA's decision says which: no answers yet, or questions still open, means ask; answers to every question means plan. You don't build it.
-
-1. **Read it.** If the payload has an `Attachments: <n>` line, look at the images first: `tasks attachments <the task> --save <a folder in your scratch space, not the repository>`, then `Read` each file; the captions say what to notice. Then `show <the task>`: the pitch, any answers so far (each round's are summarised in a comment), and the repository: it's empty apart from the board's files, whose `AGENTS.md` and prompt sections are still at their defaults.
-2. **Ask, as a decision on the IDEA.** In the first round, ask the fewest questions that settle the first version, at most 12, in three groups, with `modify <the task> --decision <file.json>` (see "Asking for a decision" below for the file):
-   - **What it is:** who it's for, what they do with it first, what the first version must have and can leave out, and how it should look and feel (images welcome).
-   - **How it's built:** the kind of thing (a website, an app on phones, a tool, a game, something else), with **Pick for me** as the first option. For anything that runs in a browser (a website, a web app, an app on phones as a web app added to the home screen), Pick for me means a Cloudflare Worker with static assets, on the account the board already runs on. Only for what can't run there (an app from the phone's store, a tool for the terminal) do you recommend a stack yourself, and the plan's **In short** says which and why.
-   - **How it runs:** where it lives (on the owner's own Cloudflare account by default, where the board already runs), who can use it (just them, people they invite, everyone), and whether the repository stays private.
-
-   Write every `prompt` in everyday words, one idea per question, with options rather than open text where they work and your recommendation first, marked "(recommended)". A technical term goes only in `help`, explained in a line. Don't ask what the pitch already answers. Then `comment` what you asked and why, `release <the task>`, and stop: the owner answers on the board, and their **Send answers and carry on** starts the next run.
-3. **Ask once more, only if you must.** If something important is still open after the first round's answers, ask a second round about only that, at most 6 questions, the same way, and stop. Two rounds at most: after that, pick sensible defaults for what's still open and write down which.
-4. **Plan it.** Once the answers settle it, check in on the peloton (step 4 above) with the spec, `AGENTS.md`, and the prompt, then shape the idea as "Shaping an idea" above says, with three additions, all in one pull request in this repository: `AGENTS.md` says how to build, test, and check the chosen stack; the repository's agent prompt replaces its default sections (**Building**, **Checks**, **Pull requests**, **Direction**, and the rest) with what this project needs; and the spec opens with **In short**, a few plain sentences someone who isn't technical can check against what they asked for, naming the stack Pick for me chose or the one you recommended. The pull request's description starts with the same sentences under an `## In short` heading: the kickoff's page on the board quotes them. Every task you add depends on the IDEA and carries one feature named for the first version, `<the repository's slug>-v1` (add it with `features add`, without a release); the first task sets up the stack, so building stays tasks. The pull request closes the IDEA; `modify <the task> --pr <number>` and watch it as in step 8.
-
-Never start an agent, a chase, or a deploy for the project, and never set `--autostart`: the owner merges the plan and starts the building from the board.
-
 ## Refining a task (`Mode: refine` in the payload)
 
 The owner wants the task made better, not built. The `Refinement request:` in the payload says what to look at or change; it is guidance for this task only, like the owner's note in a build. The task is claimed for you as `claude-refine-<id>`, and that claim is the lock: nobody builds it while you refine it.
@@ -120,7 +104,6 @@ The owner wrote what they want in their own words and pressed Start; the board m
    A general task released with no pull request is finished: the board closes it, so release only when your part is done.
 4. **Other tasks: change them directly, each change noted.** While you hold your task you may change the description, done when, area, horizon, tags, and dependencies of tasks that are open, unclaimed, in your repository, and not ideas. The board adds `Changed by <your task>: <the fields>.` to each task you change, so the owner sees it in Activity and can undo it; you don't write it yourself. Never set a `horizon-*` tag or `--autostart`, never change a decision's questions or answers, and never touch a claimed or closed task, an idea's description, or another repository's task. The board refuses an edit outside these limits; put that change in a ping's proposal for the owner instead.
 5. **A run from a decision's answers.** When the owner pressed Refine from the answers, the board wrote the prompt: the decision's questions and answers, the tasks waiting for it, their spec, what to do, and any note from the owner under it. Your task is related to the decision; `show` it for the full answers. Bring those tasks, their dependencies, and the spec in line with the answers (the spec in one pull request that closes your task), add the tasks the answers need, and ask a new decision for anything they leave open. Never change the answers: only the owner does.
-6. **A run that names a spec.** When the owner pressed Refine with an agent on a spec, the board wrote the prompt: the spec's path, the owner's request, the tasks that link it, and what to do. Your task's `spec` is that path. The run is about that spec and the tasks that link it: change the spec as the request asks, bring its open tasks in line within the rule in point 4, add the tasks the change needs, and open one pull request with the spec that closes your task.
 
 You never start or force-start an agent, never take another agent's claim, and never deploy, touch production, or merge, whatever the prompt says.
 
@@ -153,7 +136,7 @@ If `peloton` says the board has no route for it (an install from before the pelo
 
 ## Asking for a decision
 
-When something needs the owner's choice, ask it as a structured decision, not as prose in a task or a comment ([spec](../../../docs/specs/IDEA-6-decisions-with-questions.md)). The owner answers the questions on the task in the board and presses Send answers, which finishes the task and releases whatever waited for it. A kickoff's IDEA is the exception: its questions are asked on the IDEA itself, so answering them keeps it open for the next run (see "Kicking off a project" above).
+When something needs the owner's choice, ask it as a structured decision, not as prose in a task or a comment ([spec](../../../docs/specs/IDEA-6-decisions-with-questions.md)). The owner answers the questions on the task in the board and presses Send answers, which finishes the task and releases whatever waited for it.
 
 1. `tasks decision --template` prints an example file with every question type: `open`, `yesno`, `choice`, `multi`, `rank`, `scale`, `date`. Copy only what you need. Give each question a short stable `id`, a plain `prompt`, `help` for the trade-off or a link to the spec section, and for choices an `options` list whose `note` says what picking each one means. Up to 20 questions and 20 KB.
 2. Attach it: `add "<title>" --tag owner --decision <file.json> --depends <IDs> …` for a new task, or `modify <ID> --decision <file.json>` on an existing `+decide` task. Attaching adds `+decide`. Make the tasks that need the answer depend on it.

package/scripts/tasks/cli.js

@@ -14,7 +14,6 @@ export const SUBCOMMANDS = {
   horizon: ['close'],
   hook: ['session', 'wait'],
   peloton: ['checkin', 'step', 'reply'],
-  specs: ['list', 'show'],
 };
 
 /** Commands that take nothing after their name, so a word there is a mistake (an old copy's missing subcommand, say). */
@@ -49,18 +48,17 @@ export function unknownSubcommand(command, first) {
 
 /**
  * What a CLI says about where it runs from, or null to say nothing (BRK-7). The CLI ships on npm, so `packaged` (run
- * through npx) has nothing to say. In a checkout of the board's own repository, `behind` (the board's `release`, its
- * X-Tasks-Release header, isn't in this checkout's history: releaseBehind) means pull (BRK-148). Anywhere else the
- * CLI is an old copy that `repos init` used to commit: it works while the API stays compatible, and on each run it says
- * how to switch. `own` and `board` are the frozen CLI number (src/cli-version.js) such a copy carries and the board sends.
+ * through npx) has nothing to say. In a checkout of the board's own repository, `own` older than the board's (`board`,
+ * its X-Tasks-Cli header) means pull. Anywhere else the CLI is an old copy that `repos init` used to commit: it
+ * works while the API stays compatible, and on each run it says how to switch.
  */
-export function staleCliWarning({ own, board, boardCheckout, slug, packaged = false, release = null, behind = false }) {
+export function staleCliWarning({ own, board, boardCheckout, slug, packaged = false }) {
   if (packaged) return null;
   const theirs = Number(board);
   const older = Number.isInteger(theirs) && theirs > own;
   if (boardCheckout) {
-    if (!release || !behind) return null;
-    return `this checkout is behind the board's release (v${release}), so a command may be missing or behave differently: pull the default branch to update it.`;
+    if (!older) return null;
+    return `this checkout's board CLI (version ${own}) is older than the board's (${theirs}), so a command may be missing or behave differently: pull the default branch to update it.`;
   }
   const newer = older ? `, older than the board's (${theirs}), so a command may be missing or behave differently` : '';
   return `this checkout carries a copy of the board's CLI (version ${own}${newer}). The CLI is on npm now: run it as npx ${CLI_PACKAGE} <command> instead of node scripts/tasks.mjs, and remove the copy with npx ${CLI_PACKAGE} repos init ${slug || '<slug>'} --update, which opens a pull request here.`;
@@ -78,22 +76,6 @@ export function githubRequest(repo, { sync = false } = {}) {
   return ['GET', repo ? `github?repo=${encodeURIComponent(repo)}` : 'github', undefined];
 }
 
-/**
- * Whether the checkout `git` runs in is behind the board's release `release` (BRK-148): it has the release's tag
- * (`v1.4.0-main.9`, which the release workflow pushes) and that commit isn't in HEAD's history. Without the tag (tags
- * not fetched yet), or in a `shallow` clone, whose cut history can hide an ancestor, it can't tell, and says no.
- * `git(args)` runs git and returns its exit code.
- * @param {string | null} release
- * @param {(args: string[]) => number | null} git
- * @param {{ shallow?: boolean }} [options]
- */
-export function releaseBehind(release, git, { shallow = false } = {}) {
-  if (shallow || !release || !/^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/u.test(release)) return false;
-  const tag = `refs/tags/v${release}`;
-  if (git(['rev-parse', '-q', '--verify', `${tag}^{commit}`]) !== 0) return false;
-  return git(['merge-base', '--is-ancestor', tag, 'HEAD']) === 1;
-}
-
 /** What `github fix` accepts for --problem: the same three the pull request page offers. */
 export const FIX_PROBLEMS = ['conflicts', 'failing', 'review'];
 
@@ -122,30 +104,6 @@ export function pullAgentRequest(action, number, { repo = null, problem, note, f
   return { request: ['POST', `github/pulls/${n}/${action}`, body] };
 }
 
-/**
- * `npx breakaway github release <pre-release> [--next patch|minor|major]` (BRK-103, WEB-39): the owner releases a
- * package's pre-release as its stable, as Release on the GitHub page does, with what the default branch works toward
- * next. The board starts the repository's release.yml stable job, and npm waits for the owner's 2FA; it refuses an
- * agent, so the request always says who asks, and refuses a pre-release whose stable is already out (409).
- * @param {string | undefined} version the pre-release, like 1.4.0-main.5 (or its tag)
- * @param {{ repo?: string | null, by?: string, next?: string | null }} [options]
- * @returns {{ error?: string, request?: [string, string, Record<string, string>] }}
- */
-export function packageReleaseRequest(version, { repo = null, by, next = null } = {}) {
-  const v = String(version ?? '').trim();
-  if (!/^(?:\S+@|v)?\d+\.\d+\.\d+-main\.\d+$/u.test(v))
-    return { error: 'say which pre-release: npx breakaway github release <version>, like 1.4.0-main.5' };
-  if (next !== null && next !== undefined && !['patch', 'minor', 'major'].includes(String(next)))
-    return { error: '--next is patch, minor, or major' };
-  return {
-    request: [
-      'POST',
-      'github/release',
-      { version: v, ...(next ? { next: String(next) } : {}), ...(repo ? { repo } : {}), ...(by ? { by } : {}) },
-    ],
-  };
-}
-
 export const REVIEW_VERDICTS = ['ready', 'follow-up', 'changes'];
 
 /**
@@ -190,27 +148,17 @@ export function forceFields(force, by) {
  * With `decision` (`agents new --decision <ID> ["<note>"]`, BRK-110) the board writes the prompt from that answered
  * decision, in the decision's repository, and the text is the owner's note under it. With `next`
  * (`agents new --next minor|major ["<note>"]`, BRK-100) it writes the prompt that sets the repository's next version.
- * With `spec` (`agents new --spec <path> "<what should change>"`, BRK-121) it writes the prompt that refines that spec
- * and the tasks that link it, and the text, required, is what should change.
  * @param {string} prompt
- * @param {{ repo?: string | null, force?: boolean, by?: string, decision?: string | null, next?: string | null, spec?: string | null }} [options]
+ * @param {{ repo?: string | null, force?: boolean, by?: string, decision?: string | null, next?: string | null }} [options]
  */
-export function generalAgentRequest(
-  prompt,
-  { repo = null, force = false, by, decision = null, next = null, spec = null } = {},
-) {
+export function generalAgentRequest(prompt, { repo = null, force = false, by, decision = null, next = null } = {}) {
   const text = String(prompt ?? '').trim();
-  if ([decision, next, spec].filter(Boolean).length > 1)
-    return { error: 'start one from --decision, --spec, or --next: only one of them' };
+  if (decision && next) return { error: 'start one from --decision or --next, not both' };
   if (next && !['minor', 'major'].includes(next))
     return { error: 'patches count by themselves: --next minor or --next major' };
-  if (spec && !text)
-    return {
-      error: 'say what should change in the spec: npx breakaway agents new --spec <path> "<what should change>"',
-    };
   if (!text && !decision && !next)
     return { error: 'say what the agent should do: npx breakaway agents new "Tidy the docs" [--image <file>]' };
-  const board = decision ? { decision } : next ? { next } : spec ? { spec: specPath(spec) } : null;
+  const board = decision ? { decision } : next ? { next } : null;
   const body = {
     ...(board ? { ...board, ...(text ? { note: text } : {}) } : { prompt: text }),
     ...(repo ? { repo } : {}),
@@ -222,54 +170,18 @@ export function generalAgentRequest(
 
 /**
  * What the CLI says about a general agent's answer: the task and that it started, or why it waits (and whether Force
- * start could skip that), or, from a decision, for the next version (`next`), or on a spec (`spec`), the open one
- * that already has it.
+ * start could skip that), or, from a decision or for the next version (`next`), the open one that already has it.
  * @param {{ task: { wid?: string, short?: string }, run?: { url?: string, agent?: string } | null, waiting?: string | null, forceable?: boolean, already?: string | null }} answer
- * @param {{ next?: string | null, spec?: unknown }} [options]
+ * @param {{ next?: string | null }} [options]
  */
-export function generalAgentSummary({ task, run, waiting, forceable, already }, { next = null, spec = null } = {}) {
+export function generalAgentSummary({ task, run, waiting, forceable, already }, { next = null } = {}) {
   const id = task.wid ?? task.short;
-  if (!run && already) {
-    const what = next ? 'prepares the next version' : spec ? 'refines this spec' : 'refines from these answers';
-    return `${id} already ${what}: ${already}.`;
-  }
+  if (!run && already)
+    return `${id} already ${next ? 'prepares the next version' : 'refines from these answers'}: ${already}.`;
   if (run) return `Started ${run.agent ? `${run.agent} ` : 'an agent '}on ${id}${run.url ? `: ${run.url}` : ''}`;
   return `Saved ${id}, waiting to start: ${waiting ?? 'no room yet'}.${forceable ? ` Start it now past the board's limits: npx breakaway agents start ${id} --force` : ''}`;
 }
 
-/** A spec's path as the board reads it: no leading `./`, no doubled or trailing slashes. */
-const specPath = (path) =>
-  String(path ?? '')
-    .trim()
-    .replace(/^(\.\/)+/u, '')
-    .split('/')
-    .filter((part) => part && part !== '.')
-    .join('/');
-
-/**
- * The request behind `npx breakaway specs [list]` (BRK-121): the specs of the checkout's repository, or the one `--repo`
- * names; without either, the board answers with its default repository's.
- * @param {string | null} repo
- * @returns {[string, string, undefined]}
- */
-export function specsRequest(repo) {
-  return ['GET', repo ? `specs?repo=${encodeURIComponent(repo)}` : 'specs', undefined];
-}
-
-/**
- * The request behind `npx breakaway specs show <path>` (BRK-121): one spec, by its path in the repository. The board
- * refuses a path outside the specs directory; one that climbs out with `..` is refused here first.
- * @param {string | undefined} path
- * @param {string | null} repo
- */
-export function specRequest(path, repo) {
-  const clean = specPath(path);
-  if (!clean) return { error: 'say which spec: npx breakaway specs show <path>, like docs/specs/BRK-1-thing.md' };
-  if (clean.split('/').includes('..')) return { error: `${clean.slice(0, 200)} climbs out of the repository` };
-  const query = repo ? `?repo=${encodeURIComponent(repo)}` : '';
-  return { request: ['GET', `specs/${clean.split('/').map(encodeURIComponent).join('/')}${query}`, undefined] };
-}
-
 /**
  * What the CLI says about an answer to those requests: which task and agent took the pull request, or who already has it.
  * @param {'fix' | 'review'} action
@@ -497,64 +409,3 @@ export function chaseSummary(slug, { dryRun, chase, started = [], wouldStart = [
   }
   return [first, '', ...chaseLines(chase, slug)].join('\n');
 }
-
-/** A spec's tasks in a few words: "3 tasks, 2 open", or "no tasks". */
-const specTaskCount = (tasks = []) => {
-  if (!tasks.length) return 'no tasks';
-  const open = tasks.filter((t) => t.status === 'pending').length;
-  return `${plural(tasks.length, 'task')}, ${open} open`;
-};
-
-/**
- * What `npx breakaway specs` prints: the repository's specs newest first, each with its work ID, status, title, and its
- * tasks' count; with none, where specs go and how to point the board at another directory.
- * @param {{ slug: string, dir: string, missing?: boolean, readme?: { path: string } | null, specs: any[] }} answer
- */
-export function specListLines({ slug, dir, missing, readme, specs }) {
-  if (!specs.length)
-    return [
-      `No specs in ${dir} yet${missing ? `: ${slug} has no ${dir} on its default branch` : ''}.`,
-      'A spec is a Markdown file in that directory, merged like any change.',
-      `If ${slug} keeps its specs somewhere else, the owner sets it with npx breakaway repos modify ${slug} --specs <dir>.`,
-    ];
-  const intro = readme ? ` (its introduction is ${readme.path})` : '';
-  const out = [`${slug}: ${plural(specs.length, 'spec')} in ${dir}${intro}`, ''];
-  for (const s of specs) {
-    const extra = s.tooLarge ? ', over 1 MB: read it on GitHub' : '';
-    out.push(
-      `  ${(s.wid ?? '').padEnd(9)} ${(s.status ?? '-').padEnd(10)} ${s.title}  (${specTaskCount(s.tasks)}${extra})`,
-    );
-  }
-  out.push('', `Read one: npx breakaway specs show <path>, like ${specs[0].path}`);
-  return out;
-}
-
-/**
- * What `npx breakaway specs show <path>` prints: the spec's title and path, status, the commit that last changed it,
- * its GitHub link, its Markdown (or, over 1 MB, a pointer to GitHub), and the tasks that link it.
- * @param {any} spec
- */
-export function specLines(spec) {
-  const out = [`${spec.title} (${spec.path})`, ''];
-  const row = (k, v) => v && out.push(`  ${k.padEnd(11)} ${v}`);
-  row('Status', spec.status);
-  const c = spec.commit;
-  if (c)
-    row(
-      'Changed',
-      `${c.date ? `${String(c.date).slice(0, 16).replace('T', ' ')} ` : ''}in ${String(c.sha).slice(0, 7)}${c.message ? `: ${c.message}` : ''}`,
-    );
-  row('GitHub', spec.url);
-  out.push('');
-  if (spec.tooLarge || spec.text === null || spec.text === undefined)
-    out.push('Over 1 MB, too large to show here: read it on GitHub.');
-  else out.push(String(spec.text).replace(/\s+$/u, ''));
-  const tasks = spec.tasks ?? [];
-  out.push('');
-  if (tasks.length) {
-    out.push(`  Tasks (${tasks.length}, ${tasks.filter((t) => t.status === 'pending').length} open)`);
-    for (const t of tasks) out.push(`    ${idOf(t).padEnd(9)} ${t.status.padEnd(9)} ${t.description}`);
-  } else out.push(`  No task links it yet: npx breakaway modify <ref> --spec ${spec.path}`);
-  out.push('', `Refine it: npx breakaway agents new --spec ${spec.path} "<what should change>"`);
-  return out;
-}