feature-flow-cli 0.25.0__tar.gz → 0.26.0__tar.gz

{feature_flow_cli-0.25.0 → feature_flow_cli-0.26.0}/MANIFEST.in

@@ -3,6 +3,7 @@ graft skills
 graft agents
 graft guides
 graft adapters/codex
+graft packages/forkboard/forkboard
 include scripts/*.py scripts/*.html
 include LICENSE README.md install.py install.sh
-global-exclude .DS_Store
+global-exclude .DS_Store *.pyc

{feature_flow_cli-0.25.0/feature_flow_cli.egg-info → feature_flow_cli-0.26.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: feature-flow-cli
-Version: 0.25.0
+Version: 0.26.0
 Summary: A ticket-graph workflow for coding agents: installs the feature-flow skill into a repo
 License-Expression: MIT
 Project-URL: Homepage, https://github.com/hamilton-sky/feature-flow
@@ -402,10 +402,24 @@ When an idea is still fuzzy, the session can brainstorm it with you before it wr
 
 Read only helpers work for the session during a brainstorm: a code scout, a web scout, the architect, designer and product owner, `flow-skeptic`, who attacks each finished option so the session that wrote the options is not the one that judges them, and `flow-lens`, who looks at the options through one lens the session picks for the idea: `positive`, `researcher`, `open-minded`, `artistic`, `ux` or `security` ([guides/lenses/](guides/lenses/)). Each gets its prompt from `brainstorm-prompt <helper> <question file>`, which counts them: `normal` allows 2 scouts, 1 web, 2 consultants, 1 skeptic and 2 lenses per brainstorm, `careful` 3, 2, 3, 1 and 3, and `FLOW_SCOUTS=off` no scouts. Helpers never write the brainstorm and never ask you anything; the session does both.
 
-Before you pick, the session shows the brainstorm as a review page: `feature-flow brainstorm-page <feature>` (or `flow-status.py <feature> --brainstorm-page`) writes it beside the brainstorm as one HTML file. It has a sidebar that routes between the sections and shows how far you read, a system, light or dark switch, flowchart diagrams you can edit (drag, add boxes of seven kinds, colour them from 12 colours, rename and delete them, connect them with arrows, undo and redo, with the keyboard too), reset, and copy back as mermaid (the edited diagram once you change it; edits are kept only in that browser), and an arrow animation that stays off until you turn it on. Its look is a style from [guides/styles/](guides/styles/): `route` (the default) or `blueprint`, picked with `--style`, the brainstorm's `Style:` line or `FLOW_STYLE`. A style is one CSS file of colour and font tokens, so adding one is adding a file. `--fragment` leaves out the html and body tags, for publishing the page as an artifact.
+Before you pick, the session shows the brainstorm as a review page: `feature-flow brainstorm-page <feature>` (or `flow-status.py <feature> --brainstorm-page`) writes it beside the brainstorm as one HTML file. It has a sidebar that routes between the sections and shows how far you read, a system, light or dark switch, flowchart diagrams you can edit (drag, add boxes of seven kinds, colour them from 12 colours, rename and delete them, connect them with arrows, undo and redo, with the keyboard too), reset, and copy back as mermaid (the edited diagram once you change it; edits are kept only in that browser), and an arrow animation that stays off until you turn it on. Its look is a style: `route` (the default) or `blueprint`, picked with `--style`, the brainstorm's `Style:` line or `FLOW_STYLE`. A style is one CSS file of colour and font tokens in Forkboard's [themes/](packages/forkboard/forkboard/themes/), so adding one is adding a file. `--fragment` leaves out the html and body tags, for publishing the page as an artifact.
+
+![A Forkboard review page for a rate-limits brainstorm: a sidebar with the sections and options, option A's diagram with the API gateway box selected and the editing tools above it, and its pros, cons, size and risky areas below](docs/forkboard.png)
+
+What the page is good at:
+
+- **You review the design, not a wall of text.** Each option is a diagram you can see at once, with its pros, cons, size and risky areas right under it, and the sidebar jumps between options.
+- **You answer by editing the diagram itself.** Drag, add, rename, connect or delete boxes, then Copy as mermaid and paste it into the chat. Your change reaches the session as a diagram, not a paraphrase.
+- **More than one person can review it.** On the live page each reviewer keeps their own version of a diagram, compare with original marks what they added, removed or renamed, and their questions wake the session, which answers on the page.
+- **One file, nothing to install or host.** The plain page is a single HTML file that needs no server and no account: open it from disk, or publish it as an artifact. It sends nothing anywhere (it only loads its fonts, and mermaid for a diagram that is not a flowchart), and the brainstorm's text is escaped, so a label cannot run a script.
+- **Its own package, tested in a browser.** The page's editor, its phone layout and the live page's saves are driven in Chromium in CI, apart from the harness.
+
+The page itself is **Forkboard** ([packages/forkboard/](packages/forkboard/)), a separate package in this repository with its own version and tests. feature-flow turns the brainstorm into a review document and Forkboard makes the page from it; Forkboard never reads or writes the brainstorm file. Every install of feature-flow carries its copy of Forkboard (as `feature_flow/_forkboard/`), so nothing extra needs installing.
 
 **The live page (Claude only).** When the session can publish artifacts, it publishes the page live instead (`--live <folder>` writes `index.html` and a `state.json` beside it). Everyone you share it with (a claude.ai sign-in and edit access, no Claude Code needed) can save their own version of each diagram, pick between the original and anyone's version, turn on **Compare with original** to see added, removed and renamed boxes and arrows marked, ask Claude in the page to change a diagram (it uses that person's own Claude), and send the session questions from **Talk to Claude**. A save wakes the session: it reads the page's `state.json`, lists the open asks (`--asks`), answers each one (`--answer`), puts a version into the brainstorm when asked (`--apply <folder> <figure> <version>`), and publishes the next round to the same link. `/feature-flow <feature> brainstorm sketch` starts from your own drawing: the page opens with a small sketch of the idea, you draw yours and send it, and the options build on it. Without an Artifact tool (or on Codex) you get the plain page.
 
+[docs/brainstorm.md](docs/brainstorm.md) walks through a brainstorm step by step, how to use the page, and Forkboard's own commands.
+
 The result is `brainstorm.md` ([template](guides/templates/brainstorm.md)), committed with the plan. The planner follows its chosen option and copies its diagram into `spec.md`, the plan reviewer fails a plan that builds a rejected option or leaves a risky area below level 3, and a re-plan keeps the choice. It is skipped in `fast`, for an import, and with `auto`; with `agent`, the driving agent picks, the file says `Picked by: agent`, and the eval records it.
 
 ## Starting from Spec Kit or OpenSpec
@@ -457,6 +471,7 @@ feature-flow eval <feature> [--later]                     record the run in plan
 python3 scripts/flow-status.py <feature> --mermaid        the ticket graph, coloured by status (add "plain" for none)
 python3 scripts/flow-status.py <feature> --json           every ticket with status, blockers and readiness
 python3 scripts/flow-view.py <feature> [--watch]          the animated graph page, opened in your browser
+feature-flow brainstorm-page <feature> [--style NAME] [--fragment]   the brainstorm as a review page (Forkboard); --live DIR, --asks, --answer, --apply for the live page
 python3 scripts/gate.py <feature>                         run Build, Test and Lint from commands.md
 python3 scripts/floor-guard.py <feature> <NN> [base]      check a ticket's diff, run from the repo root
 ```
@@ -490,6 +505,7 @@ The commands in `commands.md` run through `bash -c` on Linux and macOS and throu
 | `FLOW_DIR`, `FLOW_TICKETS` | `plans`, `tasks` | where the plans and the ticket folder live |
 | `FLOW_NO_OPEN` | unset | `1` makes `flow-view.py` never open a browser |
 | `FLOW_WATCH_SECONDS` | `3` | how often `flow-view.py --watch` rewrites the page |
+| `FLOW_STYLE` | `route` | the brainstorm page's look when the brainstorm has no `Style:` line: `route` or `blueprint` (Forkboard's themes) |
 
 The run also stops on its own after a number of phases (`BUILD` and `REVIEW` hand-outs, the spec review and the quality review each counting as one, a single review counting as one) that grows with the ticket count, recomputed at every pick, so a loop of failures cannot go on forever.
 
@@ -517,12 +533,16 @@ Then `cd` into it, start the agent and type `/feature-flow hello` (Codex: `$feat
 ```bash
 bash tests/run.sh
 python3 -m unittest discover -s tests/py
+python3 -m unittest discover -s packages/forkboard/tests            # Forkboard, the brainstorm page
+(cd packages/forkboard/tests/browser && npm install && npm test)    # the page in Chromium
 ```
 
 Offline and free: no model is called. The suite covers the conductor's every answer and how a run stops, sessions, handoff and takeover, a `.git` the agent cannot write, the gate, the floor guard, plan protection, the prompts and guides, both skills, the installer for both agents, the graph page and its data, the Done when checks, the test-first check, the two reviews and the debugging guide on a send-back, and the acceptance harness. `tests/run.sh` also drives a prepared demo with no model through both checks and both reviews. The page's layout and replay logic are also tested under Node (`tests/viewer-logic.test.js`, skipped when Node is absent). `.github/workflows/tests.yml` runs it on every push to `main` and every pull request, on Ubuntu and on macOS. A fourth job runs the Python unit tests on Windows, including a fixture drive that takes a two-ticket plan through `python scripts/flow.py f start` and `next` to `BUILD` and then `REVIEW`, with `FLOW_TRUSTED=1` set as the runner sets it. `tests/run.sh` itself is a bash harness and does not run on Windows. Windows is tested this way only: no real agent run has been done there.
 
 A `package` job builds the wheel and the sdist and runs `tests/package_smoke.py` on Ubuntu (Python 3.9 and the latest), macOS and Windows: it installs the wheel in a fresh virtual environment, runs `feature-flow install`, and checks that the repo gets the same files as from `install.py` in a clone. Run it locally with `python3 -m pip install build && python3 tests/package_smoke.py`.
 
+Two jobs test Forkboard ([packages/forkboard/](packages/forkboard/)) on its own: its unit tests and a build-and-install smoke test on Ubuntu, macOS and Windows, and the page driven in Chromium through Playwright (the diagram editor, no sideways scroll at phone width, and a live-page save that clashes with someone else's, reloads and saves again).
+
 `RUN_REAL=1 bash tests/smoke-real.sh --interactive` is the acceptance run with Claude Code. It runs real sessions on the demo project and spends money, which is why it asks for `RUN_REAL=1`.
 
 ## Limits

{feature_flow_cli-0.25.0 → feature_flow_cli-0.26.0}/README.md

@@ -383,10 +383,24 @@ When an idea is still fuzzy, the session can brainstorm it with you before it wr
 
 Read only helpers work for the session during a brainstorm: a code scout, a web scout, the architect, designer and product owner, `flow-skeptic`, who attacks each finished option so the session that wrote the options is not the one that judges them, and `flow-lens`, who looks at the options through one lens the session picks for the idea: `positive`, `researcher`, `open-minded`, `artistic`, `ux` or `security` ([guides/lenses/](guides/lenses/)). Each gets its prompt from `brainstorm-prompt <helper> <question file>`, which counts them: `normal` allows 2 scouts, 1 web, 2 consultants, 1 skeptic and 2 lenses per brainstorm, `careful` 3, 2, 3, 1 and 3, and `FLOW_SCOUTS=off` no scouts. Helpers never write the brainstorm and never ask you anything; the session does both.
 
-Before you pick, the session shows the brainstorm as a review page: `feature-flow brainstorm-page <feature>` (or `flow-status.py <feature> --brainstorm-page`) writes it beside the brainstorm as one HTML file. It has a sidebar that routes between the sections and shows how far you read, a system, light or dark switch, flowchart diagrams you can edit (drag, add boxes of seven kinds, colour them from 12 colours, rename and delete them, connect them with arrows, undo and redo, with the keyboard too), reset, and copy back as mermaid (the edited diagram once you change it; edits are kept only in that browser), and an arrow animation that stays off until you turn it on. Its look is a style from [guides/styles/](guides/styles/): `route` (the default) or `blueprint`, picked with `--style`, the brainstorm's `Style:` line or `FLOW_STYLE`. A style is one CSS file of colour and font tokens, so adding one is adding a file. `--fragment` leaves out the html and body tags, for publishing the page as an artifact.
+Before you pick, the session shows the brainstorm as a review page: `feature-flow brainstorm-page <feature>` (or `flow-status.py <feature> --brainstorm-page`) writes it beside the brainstorm as one HTML file. It has a sidebar that routes between the sections and shows how far you read, a system, light or dark switch, flowchart diagrams you can edit (drag, add boxes of seven kinds, colour them from 12 colours, rename and delete them, connect them with arrows, undo and redo, with the keyboard too), reset, and copy back as mermaid (the edited diagram once you change it; edits are kept only in that browser), and an arrow animation that stays off until you turn it on. Its look is a style: `route` (the default) or `blueprint`, picked with `--style`, the brainstorm's `Style:` line or `FLOW_STYLE`. A style is one CSS file of colour and font tokens in Forkboard's [themes/](packages/forkboard/forkboard/themes/), so adding one is adding a file. `--fragment` leaves out the html and body tags, for publishing the page as an artifact.
+
+![A Forkboard review page for a rate-limits brainstorm: a sidebar with the sections and options, option A's diagram with the API gateway box selected and the editing tools above it, and its pros, cons, size and risky areas below](docs/forkboard.png)
+
+What the page is good at:
+
+- **You review the design, not a wall of text.** Each option is a diagram you can see at once, with its pros, cons, size and risky areas right under it, and the sidebar jumps between options.
+- **You answer by editing the diagram itself.** Drag, add, rename, connect or delete boxes, then Copy as mermaid and paste it into the chat. Your change reaches the session as a diagram, not a paraphrase.
+- **More than one person can review it.** On the live page each reviewer keeps their own version of a diagram, compare with original marks what they added, removed or renamed, and their questions wake the session, which answers on the page.
+- **One file, nothing to install or host.** The plain page is a single HTML file that needs no server and no account: open it from disk, or publish it as an artifact. It sends nothing anywhere (it only loads its fonts, and mermaid for a diagram that is not a flowchart), and the brainstorm's text is escaped, so a label cannot run a script.
+- **Its own package, tested in a browser.** The page's editor, its phone layout and the live page's saves are driven in Chromium in CI, apart from the harness.
+
+The page itself is **Forkboard** ([packages/forkboard/](packages/forkboard/)), a separate package in this repository with its own version and tests. feature-flow turns the brainstorm into a review document and Forkboard makes the page from it; Forkboard never reads or writes the brainstorm file. Every install of feature-flow carries its copy of Forkboard (as `feature_flow/_forkboard/`), so nothing extra needs installing.
 
 **The live page (Claude only).** When the session can publish artifacts, it publishes the page live instead (`--live <folder>` writes `index.html` and a `state.json` beside it). Everyone you share it with (a claude.ai sign-in and edit access, no Claude Code needed) can save their own version of each diagram, pick between the original and anyone's version, turn on **Compare with original** to see added, removed and renamed boxes and arrows marked, ask Claude in the page to change a diagram (it uses that person's own Claude), and send the session questions from **Talk to Claude**. A save wakes the session: it reads the page's `state.json`, lists the open asks (`--asks`), answers each one (`--answer`), puts a version into the brainstorm when asked (`--apply <folder> <figure> <version>`), and publishes the next round to the same link. `/feature-flow <feature> brainstorm sketch` starts from your own drawing: the page opens with a small sketch of the idea, you draw yours and send it, and the options build on it. Without an Artifact tool (or on Codex) you get the plain page.
 
+[docs/brainstorm.md](docs/brainstorm.md) walks through a brainstorm step by step, how to use the page, and Forkboard's own commands.
+
 The result is `brainstorm.md` ([template](guides/templates/brainstorm.md)), committed with the plan. The planner follows its chosen option and copies its diagram into `spec.md`, the plan reviewer fails a plan that builds a rejected option or leaves a risky area below level 3, and a re-plan keeps the choice. It is skipped in `fast`, for an import, and with `auto`; with `agent`, the driving agent picks, the file says `Picked by: agent`, and the eval records it.
 
 ## Starting from Spec Kit or OpenSpec
@@ -438,6 +452,7 @@ feature-flow eval <feature> [--later]                     record the run in plan
 python3 scripts/flow-status.py <feature> --mermaid        the ticket graph, coloured by status (add "plain" for none)
 python3 scripts/flow-status.py <feature> --json           every ticket with status, blockers and readiness
 python3 scripts/flow-view.py <feature> [--watch]          the animated graph page, opened in your browser
+feature-flow brainstorm-page <feature> [--style NAME] [--fragment]   the brainstorm as a review page (Forkboard); --live DIR, --asks, --answer, --apply for the live page
 python3 scripts/gate.py <feature>                         run Build, Test and Lint from commands.md
 python3 scripts/floor-guard.py <feature> <NN> [base]      check a ticket's diff, run from the repo root
 ```
@@ -471,6 +486,7 @@ The commands in `commands.md` run through `bash -c` on Linux and macOS and throu
 | `FLOW_DIR`, `FLOW_TICKETS` | `plans`, `tasks` | where the plans and the ticket folder live |
 | `FLOW_NO_OPEN` | unset | `1` makes `flow-view.py` never open a browser |
 | `FLOW_WATCH_SECONDS` | `3` | how often `flow-view.py --watch` rewrites the page |
+| `FLOW_STYLE` | `route` | the brainstorm page's look when the brainstorm has no `Style:` line: `route` or `blueprint` (Forkboard's themes) |
 
 The run also stops on its own after a number of phases (`BUILD` and `REVIEW` hand-outs, the spec review and the quality review each counting as one, a single review counting as one) that grows with the ticket count, recomputed at every pick, so a loop of failures cannot go on forever.
 
@@ -498,12 +514,16 @@ Then `cd` into it, start the agent and type `/feature-flow hello` (Codex: `$feat
 ```bash
 bash tests/run.sh
 python3 -m unittest discover -s tests/py
+python3 -m unittest discover -s packages/forkboard/tests            # Forkboard, the brainstorm page
+(cd packages/forkboard/tests/browser && npm install && npm test)    # the page in Chromium
 ```
 
 Offline and free: no model is called. The suite covers the conductor's every answer and how a run stops, sessions, handoff and takeover, a `.git` the agent cannot write, the gate, the floor guard, plan protection, the prompts and guides, both skills, the installer for both agents, the graph page and its data, the Done when checks, the test-first check, the two reviews and the debugging guide on a send-back, and the acceptance harness. `tests/run.sh` also drives a prepared demo with no model through both checks and both reviews. The page's layout and replay logic are also tested under Node (`tests/viewer-logic.test.js`, skipped when Node is absent). `.github/workflows/tests.yml` runs it on every push to `main` and every pull request, on Ubuntu and on macOS. A fourth job runs the Python unit tests on Windows, including a fixture drive that takes a two-ticket plan through `python scripts/flow.py f start` and `next` to `BUILD` and then `REVIEW`, with `FLOW_TRUSTED=1` set as the runner sets it. `tests/run.sh` itself is a bash harness and does not run on Windows. Windows is tested this way only: no real agent run has been done there.
 
 A `package` job builds the wheel and the sdist and runs `tests/package_smoke.py` on Ubuntu (Python 3.9 and the latest), macOS and Windows: it installs the wheel in a fresh virtual environment, runs `feature-flow install`, and checks that the repo gets the same files as from `install.py` in a clone. Run it locally with `python3 -m pip install build && python3 tests/package_smoke.py`.
 
+Two jobs test Forkboard ([packages/forkboard/](packages/forkboard/)) on its own: its unit tests and a build-and-install smoke test on Ubuntu, macOS and Windows, and the page driven in Chromium through Playwright (the diagram editor, no sideways scroll at phone width, and a live-page save that clashes with someone else's, reloads and saves again).
+
 `RUN_REAL=1 bash tests/smoke-real.sh --interactive` is the acceptance run with Claude Code. It runs real sessions on the demo project and spends money, which is why it asks for `RUN_REAL=1`.
 
 ## Limits

{feature_flow_cli-0.25.0 → feature_flow_cli-0.26.0}/adapters/codex/feature-flow/SKILL.md

@@ -15,15 +15,15 @@ The conductor is `python3 scripts/flow.py <feature> <command>`. If `scripts/flow
 
 Every conductor command (`start`, `next`, `prompt`, `verdict`, `fast`, `scouts`, `scout-prompt`, `reset`, `plan-prompt`, `plan-review-prompt`, `plan-accept`, `plan-scouts`, `plan-scout-prompt`, `consult-prompt`, `brainstorm-prompt`, `budget`, `replan-prompt`) runs through `flow-trust.py`, never `flow.py` itself. `<S>` below is the folder of the `flow.py` picked above: `scripts` for the repo's own install, else `"${FEATURE_FLOW_HOME:-$HOME/.feature-flow}/scripts"`. `flow-trust.py` is started by this loader line, which checks the file against the sha256 pinned here and runs those same bytes. Copy it exactly, replacing only `<S>`:
 
-    python3 -I -c "import hashlib,sys;b=open(sys.argv[1],'rb').read().replace(b'\r\n',b'\n');sys.exit(exec(compile(b,'flow-trust','exec')) if hashlib.sha256(b).hexdigest()==sys.argv[2] else 'flow-trust.py does not match this skill')" <S>/flow-trust.py 9532117f7d6cb0fff2b8d9886de79f727641bc02399e8922a67346bdc229c04b
+    python3 -I -c "import hashlib,sys;b=open(sys.argv[1],'rb').read().replace(b'\r\n',b'\n');sys.exit(exec(compile(b,'flow-trust','exec')) if hashlib.sha256(b).hexdigest()==sys.argv[2] else 'flow-trust.py does not match this skill')" <S>/flow-trust.py a561cb2bf1d8d8970e45065f24a736a02d9f803f09d652a26ca51b579f44cf7b
 
 A full conductor command, here `next` (any other command and its arguments go where `next` is):
 
-    FLOW_TRUST=<digest> FLOW_SESSION=<token> FLOW_INVOKE='$feature-flow' python3 -I -c "import hashlib,sys;b=open(sys.argv[1],'rb').read().replace(b'\r\n',b'\n');sys.exit(exec(compile(b,'flow-trust','exec')) if hashlib.sha256(b).hexdigest()==sys.argv[2] else 'flow-trust.py does not match this skill')" <S>/flow-trust.py 9532117f7d6cb0fff2b8d9886de79f727641bc02399e8922a67346bdc229c04b <feature> next
+    FLOW_TRUST=<digest> FLOW_SESSION=<token> FLOW_INVOKE='$feature-flow' python3 -I -c "import hashlib,sys;b=open(sys.argv[1],'rb').read().replace(b'\r\n',b'\n');sys.exit(exec(compile(b,'flow-trust','exec')) if hashlib.sha256(b).hexdigest()==sys.argv[2] else 'flow-trust.py does not match this skill')" <S>/flow-trust.py a561cb2bf1d8d8970e45065f24a736a02d9f803f09d652a26ca51b579f44cf7b <feature> next
 
 - The first line of the output is `TRUST <digest>`. Keep that digest and pass it as `FLOW_TRUST` on the next conductor call. Treat the rest as the conductor's output and act on it as below (for `prompt`, `plan-prompt` and `plan-review-prompt`, the child agent's prompt is everything after the `TRUST` line). Use `FLOW_TRUST=new` only on this session's first conductor call, or when resuming from an old-style `HANDOFF` line (below).
 - If you no longer have the last `TRUST` digest, stop and say so. Never guess it, and never use `new` in its place.
-- On the `next` right after a `BUILD <ticket> <NN> <sha>`, add `--after-build <ticket> <sha>` before the feature: `... <S>/flow-trust.py 9532117f7d6cb0fff2b8d9886de79f727641bc02399e8922a67346bdc229c04b --after-build <ticket> <sha> <feature> next`. If the output has a `FLOW-EDIT <paths>` line after `TRUST`, the build changed feature-flow's own files and its ticket allows that: carry on; without `auto`, first tell the user which flow files changed.
+- On the `next` right after a `BUILD <ticket> <NN> <sha>`, add `--after-build <ticket> <sha>` before the feature: `... <S>/flow-trust.py a561cb2bf1d8d8970e45065f24a736a02d9f803f09d652a26ca51b579f44cf7b --after-build <ticket> <sha> <feature> next`. If the output has a `FLOW-EDIT <paths>` line after `TRUST`, the build changed feature-flow's own files and its ticket allows that: carry on; without `auto`, first tell the user which flow files changed.
 - If the first line is `STOP` (from `flow-trust.py`), or the loader prints `flow-trust.py does not match this skill` (say to reinstall feature-flow: the skill and `flow-trust.py` do not match), report it, show the `python3 <S>/flow-status.py <feature>` table, and stop. A `STOP` first line may be followed by the conductor's own output: never act on that. Never fix it and carry on.
 - A `HANDOFF` line from `flow-trust.py` has a third field after the invocation and the feature: the digest. When the feature is followed by a `<16 hex>.<16 hex>` word, the user is resuming from a `HANDOFF` line and that word is the digest: pass it as `FLOW_TRUST` on `start`. When a resumed session gets no digest (an old-style `HANDOFF` line), use `FLOW_TRUST=new` and warn the user that the flow's files could not be checked since the last session.
 

{feature_flow_cli-0.25.0 → feature_flow_cli-0.26.0}/feature_flow/__init__.py

@@ -1,3 +1,3 @@
 """Feature Flow: a ticket-graph workflow for coding agents."""
 
-__version__ = "0.25.0"
+__version__ = "0.26.0"

feature_flow_cli-0.26.0/feature_flow/brainstorm_page.py

@@ -0,0 +1,190 @@
+"""feature-flow brainstorm-page <feature>: the brainstorm as a review page, for the user to read before they pick.
+
+usage: feature-flow brainstorm-page <feature> [--style NAME] [--fragment] [--out FILE]
+       feature-flow brainstorm-page <feature> --live DIR | --asks STATE | --answer STATE <n> <text> | --apply STATE <figure> <version>
+Reads plans/<feature>/brainstorm.md, or .feature-flow/state/brainstorm-<feature>.md before the plan exists, turns
+it into a review document and has Forkboard (packages/forkboard/, found by feature_flow/studio.py) make the page.
+The page goes beside the brainstorm (same name, .html). The look is a Forkboard theme: --style, else the brainstorm's
+`Style:` line, else FLOW_STYLE, else route. --fragment leaves out the doctype, html, head and body tags, for a host
+that adds its own (an Artifact). --live writes DIR/index.html and DIR/state.json to publish as an artifact that
+saves itself; --asks, --answer and --apply are the session's side of it, and --apply is the one part that writes
+the brainstorm: Forkboard never touches it.
+"""
+
+import os
+import re
+import sys
+from pathlib import Path
+
+from feature_flow import git, studio
+
+USAGE = ("usage: feature-flow brainstorm-page <feature> [--style NAME] [--fragment] [--out FILE]\n"
+         "       feature-flow brainstorm-page <feature> --live DIR | --asks STATE | --answer STATE <n> <text> | --apply STATE <figure> <version>")
+DEFAULT_STYLE = "route"
+FENCE = re.compile(r"^```mermaid[ \t]*\n(.*?)^```[ \t]*$", re.S | re.M)
+KINDS = {"chosen": "chosen", "rejected": "rejected", "open": "open", "risks for the planner": "callout"}
+
+
+def source(top, feature):
+    """The brainstorm to show: the committed one once the plan exists, else the one in the state folder."""
+    for path in (Path(top) / os.environ.get("FLOW_DIR", "plans") / feature / "brainstorm.md",
+                 Path(top) / ".feature-flow" / "state" / ("brainstorm-%s.md" % feature)):
+        if path.is_file():
+            return path
+    return None
+
+
+def parse(text):
+    """(title, meta {key: value}, intro lines, [(heading, lines, [(subheading, lines)])])."""
+    title, meta, intro, sections = "", {}, [], []
+    for line in text.splitlines():
+        if line.startswith("# ") and not title and not sections:
+            title = line[2:].strip()
+        elif line.startswith("## "):
+            sections.append((line[3:].strip(), [], []))
+        elif line.startswith("### ") and sections:
+            sections[-1][2].append((line[4:].strip(), []))
+        elif sections:
+            (sections[-1][2][-1][1] if sections[-1][2] else sections[-1][1]).append(line)
+        else:
+            m = re.match(r"^([A-Z][A-Za-z ]{1,20}):\s*(.+)$", line)
+            if m and not any(l.strip() for l in intro):
+                meta[m.group(1).strip().lower()] = m.group(2).strip()
+            else:
+                intro.append(line)
+    return title, meta, intro, sections
+
+
+def document(text, feature):
+    """The brainstorm as a Forkboard review document: which section is Chosen, Rejected or Open, and which option
+    the Chosen line picks, are the brainstorm's own conventions (guides/brainstorm.md), so they are read here."""
+    title, meta, intro, sections = parse(text)
+    chosen = ""
+    for heading, lines, subs in sections:
+        if heading.lower() == "chosen":
+            chosen = " ".join(l.strip() for l in lines if l.strip())[:200]
+    out = []
+    for heading, lines, subs in sections:
+        items = []
+        for sub, sub_lines in subs:
+            letter = re.match(r"^([A-Z])[.)]\s", sub)
+            items.append({"title": sub, "label": letter.group(1) if letter else "",
+                          "chosen": bool(letter and re.match(r"^\W*%s\b" % letter.group(1), chosen)),
+                          "markdown": "\n".join(sub_lines)})
+        out.append({"title": heading, "kind": KINDS.get(heading.lower(), "text"), "markdown": "\n".join(lines),
+                    "items": items})
+    return {"schema": studio.MAJOR, "id": feature, "kind": "Brainstorm", "title": title, "meta": meta,
+            "intro": "\n".join(intro), "sections": out}
+
+
+def apply(text, fb, st, figure, version):
+    """The brainstorm text with figure `figure` replaced by that version of it, and what the rewrite dropped."""
+    graph, source_print = fb.live.version(st, figure, version)
+    blocks = list(FENCE.finditer(text))
+    if not str(figure).isdigit() or not 1 <= int(figure) <= len(blocks):
+        raise ValueError("the brainstorm file has %d diagrams, so no figure %s: build the page again" % (len(blocks), figure))
+    block = blocks[int(figure) - 1]
+    if source_print and fb.graph.fingerprint(block.group(1)) != source_print:
+        raise ValueError("figure %s in the brainstorm changed since the page was built: build the page again (--live), "
+                         "publish it, and apply after the next save" % figure)
+    return text[:block.start(1)] + fb.graph.mermaid(graph) + "\n" + text[block.end(1):], fb.graph.lost(block.group(1))
+
+
+def main(argv, out=None, err=None):
+    out = out or sys.stdout
+    err = err or sys.stderr
+    args, style, fragment, target, live, tool, extra = [], None, False, None, None, None, []
+    i = 0
+    while i < len(argv):
+        a = argv[i]
+        if a == "--fragment":
+            fragment = True
+        elif a in ("--live", "--asks") and i + 1 < len(argv) and tool is None and live is None:
+            live, tool = argv[i + 1], a[2:]
+            i += 1
+        elif a == "--answer" and i + 3 < len(argv) and tool is None:
+            live, tool, extra = argv[i + 1], "answer", argv[i + 2:i + 4]
+            i += 3
+        elif a == "--apply" and i + 3 < len(argv) and tool is None:
+            live, tool, extra = argv[i + 1], "apply", argv[i + 2:i + 4]
+            i += 3
+        elif a in ("--style", "--out") and i + 1 < len(argv):
+            if a == "--style":
+                style = argv[i + 1]
+            else:
+                target = argv[i + 1]
+            i += 1
+        elif a.startswith("-"):
+            err.write(USAGE + "\n")
+            return 2
+        else:
+            args.append(a)
+        i += 1
+    if len(args) != 1 or any(c in args[0] for c in "/\\:"):
+        err.write(USAGE + "\n")
+        return 2
+    feature = args[0]
+    top = git.toplevel() or os.getcwd()
+    path = source(top, feature)
+    if path is None:
+        err.write("no brainstorm for %s: write .feature-flow/state/brainstorm-%s.md first (brainstorm guide)\n"
+                  % (feature, feature))
+        return 1
+    fb = studio.load()
+    if fb is None:
+        err.write(studio.MISSING)
+        return 1
+    text = path.read_text(encoding="utf-8", errors="replace")
+    if tool in ("asks", "answer", "apply"):
+        return live_tool(fb, tool, path, text, Path(live), extra, out, err)
+    names = fb.page.themes()
+    _, meta, _, _ = parse(text)
+    name = (style or meta.get("style") or os.environ.get("FLOW_STYLE") or DEFAULT_STYLE).strip().lower()
+    if name not in names:
+        err.write("no style %s: pick one of %s (Forkboard's themes)\n" % (name, ", ".join(names) or "none installed"))
+        return 1
+    css = fb.page.theme_css(name)
+    doc = document(text, feature)
+    if tool == "live":  # the page and its state, to publish together as an artifact that saves itself
+        folder = Path(live)
+        folder.mkdir(parents=True, exist_ok=True)
+        st = fb.live.state(doc, fb.live.load(folder / "state.json"))
+        (folder / "index.html").write_text(fb.page.render(doc, css, name, True, True), encoding="utf-8")
+        (folder / "state.json").write_text(fb.live.dump(st), encoding="utf-8")
+        out.write("wrote %s and %s (round %d, %d figures, %d open asks)\n" % (
+            (folder / "index.html").as_posix(), (folder / "state.json").as_posix(), st["round"], len(st["figures"]),
+            sum(1 for a in st["asks"] if not a.get("answer"))))
+        return 0
+    dest = Path(target) if target else path.with_suffix(".html")
+    dest.write_text(fb.page.render(doc, css, name, fragment), encoding="utf-8")
+    out.write("wrote %s\n" % dest.as_posix())
+    return 0
+
+
+def live_tool(fb, tool, path, text, state_path, extra, out, err):
+    if state_path.is_dir():
+        state_path = state_path / "state.json"
+    st = fb.live.load(state_path)
+    if st is None:
+        err.write("no page state at %s: read the published page's state.json into it first (brainstorm guide)\n"
+                  % state_path.as_posix())
+        return 1
+    try:
+        if tool == "asks":
+            out.write(fb.live.asks(st) + "\n")
+        elif tool == "answer":
+            if not extra[0].isdigit():
+                raise ValueError("the ask number must be a number, not %s" % extra[0])
+            state_path.write_text(fb.live.dump(fb.live.answer(st, int(extra[0]), extra[1])), encoding="utf-8")
+            out.write("answered ask %s in %s\n" % (extra[0], state_path.as_posix()))
+        else:
+            new, dropped = apply(text, fb, st, extra[0], extra[1])
+            path.write_text(new, encoding="utf-8")
+            if dropped:
+                err.write("note: figure %s had %s, which the page does not keep; they are gone from the brainstorm now\n"
+                          % (extra[0], ", ".join(dropped)))
+            out.write("figure %s in %s is now version %s\n" % (extra[0], path.as_posix(), extra[1]))
+    except ValueError as e:
+        err.write("%s\n" % e)
+        return 1
+    return 0

{feature_flow_cli-0.25.0 → feature_flow_cli-0.26.0}/feature_flow/install.py

@@ -205,6 +205,10 @@ class Installer:
         if not os.path.isfile(package + "/__init__.py"):
             package = os.path.dirname(os.path.abspath(__file__))
         self.package = package
+        # Forkboard, the brainstorm's review page: packages/forkboard/ in a checkout; an installed package has it
+        # inside already, as feature_flow/_forkboard/, and copies it with the rest
+        forkboard = here + "/packages/forkboard/forkboard"
+        self.forkboard = forkboard if os.path.isfile(forkboard + "/__init__.py") else None
         self.added = self.updated = self.same = self.kept = 0
         self.written = {}
         # each folder this installs into, with its hash record; the conductor's own folder comes first
@@ -469,11 +473,15 @@ class Installer:
             self.copy_tree(here + "/guides", self.flow_dir + "/guides")
             self.copy_tree(here + "/agents", self.flow_dir + "/agents")
             self.copy_tree(self.package, self.flow_dir + "/feature_flow", skip=BUNDLE)
+            if self.forkboard:
+                self.copy_tree(self.forkboard, self.flow_dir + "/feature_flow" + "/_forkboard")
         else:
             self.copy_tree(here + "/scripts", self.target + "/scripts")
             self.copy_tree(here + "/guides", self.target + "/.feature-flow/guides")
             self.copy_tree(here + "/agents", self.target + "/.feature-flow/agents")
             self.copy_tree(self.package, self.target + "/.feature-flow/feature_flow", skip=BUNDLE)
+            if self.forkboard:
+                self.copy_tree(self.forkboard, self.target + "/.feature-flow/feature_flow" + "/_forkboard")
         listed = not self.dry and self.write_installed()
 
         self.out("")

feature_flow_cli-0.26.0/feature_flow/studio.py

@@ -0,0 +1,47 @@
+"""Finds Forkboard, the review page feature-flow's brainstorm uses (packages/forkboard/ in this repository).
+
+It sits in one of three places: feature_flow/_forkboard/ (a repo or home install, and the installed package),
+packages/forkboard/forkboard/ beside feature_flow/ (a checkout, or the Claude Code plugin), or wherever Python
+finds an installed forkboard (pip install forkboard). The first two are loaded by path, as feature_flow itself is,
+so a run under python3 -I finds them too.
+"""
+
+import importlib
+import importlib.util
+import sys
+from pathlib import Path
+
+MAJOR = "bundle/1"  # the review document format this feature-flow writes
+
+
+def load():
+    """The forkboard package, or None when there is none or it reads another major of the document format."""
+    module = sys.modules.get("forkboard")
+    if module is None:
+        here = Path(__file__).resolve().parent
+        for folder in (here / "_forkboard", here.parent / "packages" / "forkboard" / "forkboard"):
+            if (folder / "__init__.py").is_file():
+                spec = importlib.util.spec_from_file_location("forkboard", str(folder / "__init__.py"),
+                                                              submodule_search_locations=[str(folder)])
+                module = importlib.util.module_from_spec(spec)
+                sys.modules["forkboard"] = module
+                try:
+                    spec.loader.exec_module(module)
+                except Exception:
+                    del sys.modules["forkboard"]
+                    raise
+                break
+        else:
+            try:
+                module = importlib.import_module("forkboard")
+            except ImportError:
+                return None
+    if str(getattr(module, "SCHEMA", "")).split(".")[0] != MAJOR:
+        return None
+    for name in ("doc", "graph", "page", "live"):
+        importlib.import_module("forkboard." + name)
+    return module
+
+
+MISSING = ("forkboard is not here, so there is no review page: reinstall feature-flow (install.py or "
+           "pip install -U feature-flow-cli), or pip install forkboard\n")

{feature_flow_cli-0.25.0 → feature_flow_cli-0.26.0/feature_flow_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: feature-flow-cli
-Version: 0.25.0
+Version: 0.26.0
 Summary: A ticket-graph workflow for coding agents: installs the feature-flow skill into a repo
 License-Expression: MIT
 Project-URL: Homepage, https://github.com/hamilton-sky/feature-flow
@@ -402,10 +402,24 @@ When an idea is still fuzzy, the session can brainstorm it with you before it wr
 
 Read only helpers work for the session during a brainstorm: a code scout, a web scout, the architect, designer and product owner, `flow-skeptic`, who attacks each finished option so the session that wrote the options is not the one that judges them, and `flow-lens`, who looks at the options through one lens the session picks for the idea: `positive`, `researcher`, `open-minded`, `artistic`, `ux` or `security` ([guides/lenses/](guides/lenses/)). Each gets its prompt from `brainstorm-prompt <helper> <question file>`, which counts them: `normal` allows 2 scouts, 1 web, 2 consultants, 1 skeptic and 2 lenses per brainstorm, `careful` 3, 2, 3, 1 and 3, and `FLOW_SCOUTS=off` no scouts. Helpers never write the brainstorm and never ask you anything; the session does both.
 
-Before you pick, the session shows the brainstorm as a review page: `feature-flow brainstorm-page <feature>` (or `flow-status.py <feature> --brainstorm-page`) writes it beside the brainstorm as one HTML file. It has a sidebar that routes between the sections and shows how far you read, a system, light or dark switch, flowchart diagrams you can edit (drag, add boxes of seven kinds, colour them from 12 colours, rename and delete them, connect them with arrows, undo and redo, with the keyboard too), reset, and copy back as mermaid (the edited diagram once you change it; edits are kept only in that browser), and an arrow animation that stays off until you turn it on. Its look is a style from [guides/styles/](guides/styles/): `route` (the default) or `blueprint`, picked with `--style`, the brainstorm's `Style:` line or `FLOW_STYLE`. A style is one CSS file of colour and font tokens, so adding one is adding a file. `--fragment` leaves out the html and body tags, for publishing the page as an artifact.
+Before you pick, the session shows the brainstorm as a review page: `feature-flow brainstorm-page <feature>` (or `flow-status.py <feature> --brainstorm-page`) writes it beside the brainstorm as one HTML file. It has a sidebar that routes between the sections and shows how far you read, a system, light or dark switch, flowchart diagrams you can edit (drag, add boxes of seven kinds, colour them from 12 colours, rename and delete them, connect them with arrows, undo and redo, with the keyboard too), reset, and copy back as mermaid (the edited diagram once you change it; edits are kept only in that browser), and an arrow animation that stays off until you turn it on. Its look is a style: `route` (the default) or `blueprint`, picked with `--style`, the brainstorm's `Style:` line or `FLOW_STYLE`. A style is one CSS file of colour and font tokens in Forkboard's [themes/](packages/forkboard/forkboard/themes/), so adding one is adding a file. `--fragment` leaves out the html and body tags, for publishing the page as an artifact.
+
+![A Forkboard review page for a rate-limits brainstorm: a sidebar with the sections and options, option A's diagram with the API gateway box selected and the editing tools above it, and its pros, cons, size and risky areas below](docs/forkboard.png)
+
+What the page is good at:
+
+- **You review the design, not a wall of text.** Each option is a diagram you can see at once, with its pros, cons, size and risky areas right under it, and the sidebar jumps between options.
+- **You answer by editing the diagram itself.** Drag, add, rename, connect or delete boxes, then Copy as mermaid and paste it into the chat. Your change reaches the session as a diagram, not a paraphrase.
+- **More than one person can review it.** On the live page each reviewer keeps their own version of a diagram, compare with original marks what they added, removed or renamed, and their questions wake the session, which answers on the page.
+- **One file, nothing to install or host.** The plain page is a single HTML file that needs no server and no account: open it from disk, or publish it as an artifact. It sends nothing anywhere (it only loads its fonts, and mermaid for a diagram that is not a flowchart), and the brainstorm's text is escaped, so a label cannot run a script.
+- **Its own package, tested in a browser.** The page's editor, its phone layout and the live page's saves are driven in Chromium in CI, apart from the harness.
+
+The page itself is **Forkboard** ([packages/forkboard/](packages/forkboard/)), a separate package in this repository with its own version and tests. feature-flow turns the brainstorm into a review document and Forkboard makes the page from it; Forkboard never reads or writes the brainstorm file. Every install of feature-flow carries its copy of Forkboard (as `feature_flow/_forkboard/`), so nothing extra needs installing.
 
 **The live page (Claude only).** When the session can publish artifacts, it publishes the page live instead (`--live <folder>` writes `index.html` and a `state.json` beside it). Everyone you share it with (a claude.ai sign-in and edit access, no Claude Code needed) can save their own version of each diagram, pick between the original and anyone's version, turn on **Compare with original** to see added, removed and renamed boxes and arrows marked, ask Claude in the page to change a diagram (it uses that person's own Claude), and send the session questions from **Talk to Claude**. A save wakes the session: it reads the page's `state.json`, lists the open asks (`--asks`), answers each one (`--answer`), puts a version into the brainstorm when asked (`--apply <folder> <figure> <version>`), and publishes the next round to the same link. `/feature-flow <feature> brainstorm sketch` starts from your own drawing: the page opens with a small sketch of the idea, you draw yours and send it, and the options build on it. Without an Artifact tool (or on Codex) you get the plain page.
 
+[docs/brainstorm.md](docs/brainstorm.md) walks through a brainstorm step by step, how to use the page, and Forkboard's own commands.
+
 The result is `brainstorm.md` ([template](guides/templates/brainstorm.md)), committed with the plan. The planner follows its chosen option and copies its diagram into `spec.md`, the plan reviewer fails a plan that builds a rejected option or leaves a risky area below level 3, and a re-plan keeps the choice. It is skipped in `fast`, for an import, and with `auto`; with `agent`, the driving agent picks, the file says `Picked by: agent`, and the eval records it.
 
 ## Starting from Spec Kit or OpenSpec
@@ -457,6 +471,7 @@ feature-flow eval <feature> [--later]                     record the run in plan
 python3 scripts/flow-status.py <feature> --mermaid        the ticket graph, coloured by status (add "plain" for none)
 python3 scripts/flow-status.py <feature> --json           every ticket with status, blockers and readiness
 python3 scripts/flow-view.py <feature> [--watch]          the animated graph page, opened in your browser
+feature-flow brainstorm-page <feature> [--style NAME] [--fragment]   the brainstorm as a review page (Forkboard); --live DIR, --asks, --answer, --apply for the live page
 python3 scripts/gate.py <feature>                         run Build, Test and Lint from commands.md
 python3 scripts/floor-guard.py <feature> <NN> [base]      check a ticket's diff, run from the repo root
 ```
@@ -490,6 +505,7 @@ The commands in `commands.md` run through `bash -c` on Linux and macOS and throu
 | `FLOW_DIR`, `FLOW_TICKETS` | `plans`, `tasks` | where the plans and the ticket folder live |
 | `FLOW_NO_OPEN` | unset | `1` makes `flow-view.py` never open a browser |
 | `FLOW_WATCH_SECONDS` | `3` | how often `flow-view.py --watch` rewrites the page |
+| `FLOW_STYLE` | `route` | the brainstorm page's look when the brainstorm has no `Style:` line: `route` or `blueprint` (Forkboard's themes) |
 
 The run also stops on its own after a number of phases (`BUILD` and `REVIEW` hand-outs, the spec review and the quality review each counting as one, a single review counting as one) that grows with the ticket count, recomputed at every pick, so a loop of failures cannot go on forever.
 
@@ -517,12 +533,16 @@ Then `cd` into it, start the agent and type `/feature-flow hello` (Codex: `$feat
 ```bash
 bash tests/run.sh
 python3 -m unittest discover -s tests/py
+python3 -m unittest discover -s packages/forkboard/tests            # Forkboard, the brainstorm page
+(cd packages/forkboard/tests/browser && npm install && npm test)    # the page in Chromium
 ```
 
 Offline and free: no model is called. The suite covers the conductor's every answer and how a run stops, sessions, handoff and takeover, a `.git` the agent cannot write, the gate, the floor guard, plan protection, the prompts and guides, both skills, the installer for both agents, the graph page and its data, the Done when checks, the test-first check, the two reviews and the debugging guide on a send-back, and the acceptance harness. `tests/run.sh` also drives a prepared demo with no model through both checks and both reviews. The page's layout and replay logic are also tested under Node (`tests/viewer-logic.test.js`, skipped when Node is absent). `.github/workflows/tests.yml` runs it on every push to `main` and every pull request, on Ubuntu and on macOS. A fourth job runs the Python unit tests on Windows, including a fixture drive that takes a two-ticket plan through `python scripts/flow.py f start` and `next` to `BUILD` and then `REVIEW`, with `FLOW_TRUSTED=1` set as the runner sets it. `tests/run.sh` itself is a bash harness and does not run on Windows. Windows is tested this way only: no real agent run has been done there.
 
 A `package` job builds the wheel and the sdist and runs `tests/package_smoke.py` on Ubuntu (Python 3.9 and the latest), macOS and Windows: it installs the wheel in a fresh virtual environment, runs `feature-flow install`, and checks that the repo gets the same files as from `install.py` in a clone. Run it locally with `python3 -m pip install build && python3 tests/package_smoke.py`.
 
+Two jobs test Forkboard ([packages/forkboard/](packages/forkboard/)) on its own: its unit tests and a build-and-install smoke test on Ubuntu, macOS and Windows, and the page driven in Chromium through Playwright (the diagram editor, no sideways scroll at phone width, and a live-page save that clashes with someone else's, reloads and saves again).
+
 `RUN_REAL=1 bash tests/smoke-real.sh --interactive` is the acceptance run with Claude Code. It runs real sessions on the demo project and spends money, which is why it asks for `RUN_REAL=1`.
 
 ## Limits

{feature_flow_cli-0.25.0 → feature_flow_cli-0.26.0}/feature_flow_cli.egg-info/SOURCES.txt

@@ -20,7 +20,6 @@ agents/ticket-builder.md
 agents/ticket-reviewer.md
 feature_flow/__init__.py
 feature_flow/__main__.py
-feature_flow/brainstorm_live.py
 feature_flow/brainstorm_page.py
 feature_flow/checks.py
 feature_flow/cli.py
@@ -43,6 +42,7 @@ feature_flow/report.py
 feature_flow/scouts.py
 feature_flow/state.py
 feature_flow/status.py
+feature_flow/studio.py
 feature_flow/suggest.py
 feature_flow/tickets.py
 feature_flow/uninstall.py
@@ -71,8 +71,6 @@ guides/lenses/positive.md
 guides/lenses/researcher.md
 guides/lenses/security.md
 guides/lenses/ux.md
-guides/styles/blueprint.css
-guides/styles/route.css
 guides/templates/brainstorm.md
 guides/templates/commands.md
 guides/templates/learnings.md
@@ -80,6 +78,19 @@ guides/templates/map.md
 guides/templates/spec.md
 guides/templates/ticket.md
 guides/templates/ui-mockup.md
+packages/forkboard/forkboard/__init__.py
+packages/forkboard/forkboard/__main__.py
+packages/forkboard/forkboard/cli.py
+packages/forkboard/forkboard/doc.py
+packages/forkboard/forkboard/graph.py
+packages/forkboard/forkboard/live.py
+packages/forkboard/forkboard/page.py
+packages/forkboard/forkboard/assets/base.css
+packages/forkboard/forkboard/assets/editor.js
+packages/forkboard/forkboard/assets/live.css
+packages/forkboard/forkboard/assets/live.js
+packages/forkboard/forkboard/themes/blueprint.css
+packages/forkboard/forkboard/themes/route.css
 scripts/floor-guard.py
 scripts/flow-status.py
 scripts/flow-trust.py

{feature_flow_cli-0.25.0 → feature_flow_cli-0.26.0}/guides/brainstorm.md

@@ -49,7 +49,7 @@ If the choice turns on module boundaries, a screen or scope, ask the `architect`
 
 ## Step 4: The user picks
 
-Write the brainstorm file (below) with the options and no Chosen yet, then make it a review page: `python3 scripts/flow-status.py <feature> --brainstorm-page` writes `.feature-flow/state/brainstorm-<feature>.html` beside it, with a sidebar for the sections, a light, dark or system switch, diagrams whose boxes the user can drag, and an arrow animation they can turn on. The look is the brainstorm's `Style:` line (`route` unless the user asks for another style in `guides/styles/`). If you can publish an artifact, add `--fragment` and publish that file; otherwise give the user the file's path to open. Then show the options and your pick, and ask: which one? They may pick, edit, mix, or drop the brainstorm. On a drop, delete the file and write the brief as before.
+Write the brainstorm file (below) with the options and no Chosen yet, then make it a review page: `python3 scripts/flow-status.py <feature> --brainstorm-page` writes `.feature-flow/state/brainstorm-<feature>.html` beside it, with a sidebar for the sections, a light, dark or system switch, diagrams whose boxes the user can drag, and an arrow animation they can turn on. The look is the brainstorm's `Style:` line (`route`, or `blueprint` if the user asks for it). If you can publish an artifact, add `--fragment` and publish that file; otherwise give the user the file's path to open. Then show the options and your pick, and ask: which one? They may pick, edit, mix, or drop the brainstorm. On a drop, delete the file and write the brief as before.
 
 Write the file with the shell, not a file tool, from [templates/brainstorm.md](templates/brainstorm.md), and again with Chosen and Rejected filled in once the user picks (make the page again if they want to see it):
 

feature_flow_cli-0.26.0/packages/forkboard/forkboard/__init__.py

@@ -0,0 +1,8 @@
+"""Forkboard: review a design on its diagrams before the code is written.
+
+A tool (feature-flow, or anything that can write JSON) hands Forkboard a review document; Forkboard makes it a
+page people read, edit and ask questions on, and gives the tool back what they did. See README.md.
+"""
+
+__version__ = "0.1.0"
+SCHEMA = "bundle/1"  # the review document's format; a reader refuses a major it does not know

feature_flow_cli-0.26.0/packages/forkboard/forkboard/__main__.py

@@ -0,0 +1,3 @@
+from .cli import main_exit
+
+main_exit()