Stories

---
name: stories
description: Decompose a Requivo session's model into implementable user stories, in this Claude session, and save them as a tracked artifact. Use when the user wants a delivery-planner's breakdown of the model into shippable slices.
allowed-tools: Bash(requivo doctor:*), Bash(requivo model show:*), Bash(requivo status:*), Bash(requivo schema:*), Bash(requivo artifact save:*), Read
---

# /requivo:stories

Decompose the model into **implementable user stories** — the units a dev team would actually build
and ship. **You** do the decomposition; Requivo tracks the document. This mirrors
`src/requivo/assets/prompts/stories.md` and the `Stories` contract in `core/contracts.py`, at commit
`969cfd9` — the same rules the CLI's `requivo stories` gives its own reasoning call, restated here
because the plugin cannot import that file at runtime (`decision:
plugin-skills-mirror-a-pinned-cli-commit`). Read `${CLAUDE_PLUGIN_ROOT}/REASONING.md` unless you already hold it from an earlier
`/requivo:*` in this conversation — and read it again whenever you are unsure you still do.

## 0. Preflight
Run the shared **preflight** from REASONING.md before anything else: `requivo doctor --json`, checking
whether the command ran *at all* rather than what it reported. If it could not run, the `requivo` CLI
is not installed — follow REASONING.md's missing-CLI flow. Nothing has been saved at this
point, so there is no half-written stories document to find.

## 1. Load the model
```
requivo model show <slug>
requivo status <slug> --json
```
Note the `revision` — call it `N`. It is the model these stories will rest on, and you will state it
when you save.

## 2. Reason → decompose into stories
- Derive stories from what the model **says**. Do not invent scope the model doesn't support. A value
  it holds as a proposal or a domain fact (`proposed:` or `domain:` evidence) is buildable, its
  acceptance line tagged from REASONING.md's *Source tags* and phrased to confirm; a new proposal of
  yours goes to `/requivo:prd` or `/requivo:run`, which write it back (REASONING.md, *a document that
  proposes*).
- One story = one shippable slice of behavior, independently testable. Split by workflow step / actor
  / rule, **not** by technical layer (no "build the database" story).
- Aim for 3–8 stories, ordered by delivery priority. Each has an `id` (`S1`, `S2`, …), a title, an
  `as a / I want / so that`, and 2–5 checkable acceptance lines.
- Every story lists the topics it traces back to — say them in plain business language (the slot's
  `label`, e.g. "business rules", never the raw slot id like `business_rules`; run `requivo schema
  --framework` if you need the label for one you are unsure of).
- Honour `confidence` and `impact`: `explicit` gets a firm acceptance line; `inferred` gets one phrased
  as the behaviour *to confirm*; `empty` + high impact still gets the story, with an explicit "To
  decide before build: …" line rather than a paper-over; `empty` + low impact can be left out or noted
  briefly. Where two behaviours are both plausible and unconfirmed, state the open choice rather than
  silently picking one.
- Fold in the model's reasoning layer where present: a `decisions` entry's settled approach belongs in
  the acceptance criteria (carry the `tradeoff` where it matters); a `challenges` entry that has not
  been resolved becomes a "To decide before build: …" line presenting the alternative, never a side
  picked silently. `opportunities` are out of scope for stories.

**Voice.** No slot ids, percentages or confidence labels in the prose — say the business thing
("to confirm", "to decide"), never `inferred` or a completeness number.

**Language.** Stories anchor English whatever language the request arrived in — they feed dev teams
and trackers, unlike the mirrored conversation (`docs/requirements-model.md`, *The language of the
outputs*).

Write it as Markdown, one section per story:

```
# User stories

> User stories — generated by Requivo

## S1 — <title>

As a <as_a>, I want <i_want>, so that <so_that>.

**Acceptance**

- [ ] <criterion>
- [ ] <criterion>

_Traces to: <label>, <label>_
```

## 3. Save it as a tracked artifact
Pass the document on stdin — no temp file:
```
requivo artifact save <slug> --type stories --file - --revision N --json
```
`--revision N` is the revision you read in step 1. Read `stale` back from the save output: if it is
`true`, the model moved while you were writing — say so plainly and offer to redo it.

## 4. Point at the next step, once
Stories are what an estimate is reasoned against: `/requivo:estimate <slug>` produces a day-based
range per story, from the same model, and saves both together against one revision. If the stories
themselves need rework first, `/requivo:run <slug>` is where an answer goes back into the model.