feature-flow-cli 0.1.0__py3-none-any.whl

feature_flow/view.py

@@ -0,0 +1,312 @@
+"""The graph page writer, ported from the bash flow-view script with the same output and exit codes.
+
+usage: python3 scripts/flow-view.py <feature> [--watch] [--no-open] [--out FILE]
+writes one self contained HTML page that shows the ticket graph, animated, and opens it.
+the page can replay the run from git history.
+--watch rewrites the page every few seconds until the feature is complete.
+env: FLOW_DIR, FLOW_TICKETS (ticket location), FLOW_NO_OPEN=1 (never open a browser),
+     FLOW_WATCH_SECONDS (default 3)
+
+The page is scripts/flow-view.html (next to the script that was run) with the plan's data put in
+place of __FLOW_DATA__. The template and the data are handled as bytes, so the page matches the
+bash version byte for byte. Where the awks the bash version ran under disagree, this port reads
+the ticket text as characters (gawk in a UTF-8 locale: a cut never splits a character) and treats
+a line of spaces, tabs, carriage returns, vertical tabs and form feeds as blank (mawk).
+"""
+
+import os
+import re
+import shutil
+import subprocess
+import sys
+import tempfile
+import time
+
+from feature_flow import status, tickets
+
+USAGE = "usage: python3 scripts/flow-view.py <feature> [--watch] [--no-open] [--out FILE]"
+REFRESH = b'<meta http-equiv="refresh" content="3">'
+BLANK = " \t\n\r\v\f"  # what splits fields in mawk; a line made only of these has NF == 0
+_UPPER = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+_ASCII_LOWER = str.maketrans(_UPPER, _UPPER.lower())
+_SLEEP = re.compile(r"^([0-9]+\.?[0-9]*|\.[0-9]+)([smhd]?)$")
+_UNITS = {"": 1, "s": 1, "m": 60, "h": 3600, "d": 86400}
+
+
+class Stop(Exception):
+    """Ends the run with an exit code, the way set -e ends the bash script."""
+
+    def __init__(self, code):
+        Exception.__init__(self, code)
+        self.code = code
+
+
+class _Text:
+    def __init__(self):
+        self.text = ""
+
+    def write(self, text):
+        self.text += text
+
+
+class _Null:
+    def write(self, text):
+        pass
+
+
+def _lower(s):
+    """awk's tolower as mawk does it: ASCII letters only."""
+    return s.translate(_ASCII_LOWER)
+
+
+def extras(path):
+    """The awk ticket_extras program: Done when bullets, the Answer excerpt and the review rounds.
+
+    Returns the object without its closing brace, as the bash version prints it."""
+    sect = ""
+    rounds, done_when, ans = [], [], ""
+    for line in tickets.records(path):
+        if line.startswith("## "):
+            sect = _lower(line[3:])
+            if sect.startswith("review findings"):
+                n, src = 0, ""
+                m = re.search(r"round [0-9]+", line)
+                if m:
+                    n = int(m.group(0)[6:])
+                m = re.search(r", [^)]*\)", line)
+                if m:
+                    src = m.group(0)[2:-1]
+                rounds.append('{"n":%d,"source":%s}' % (n, status.jstr(src)))
+            continue
+        if sect == "done when" and line.startswith("- ") and len(done_when) < 8:
+            done_when.append(status.jstr(line[2:][:240]))
+            continue
+        if sect == "answer" and line.strip(BLANK) and not line.startswith("<") and len(ans) < 700:
+            ans = line if ans == "" else ans + "\001" + line
+    if "left empty until" in ans:
+        ans = ""
+    return '{"done_when":[%s],"answer":%s,"rounds":[%s]' % (",".join(done_when), status.jstr(ans[:700]),
+                                                          ",".join(rounds))
+
+
+def _git(args):
+    """git's stdout as bytes, whatever its exit code; b"" when git cannot run. stderr is dropped."""
+    try:
+        return subprocess.run(["git"] + args, stdout=subprocess.PIPE, stderr=subprocess.DEVNULL).stdout
+    except OSError:
+        return b""
+
+
+def show_status(blob):
+    """The status word the bash history awk prints for a ticket as git stored it, or b""."""
+    for line in blob.split(b"\n")[:20]:
+        if line.startswith(b"Status:"):
+            s = re.sub(rb"^Status:[ \t]*", b"", line.rstrip(b"\r")).lower()
+            s = re.sub(rb"[ \t(].*$", b"", s, flags=re.S)
+            if s in (b"resolved", b"done", b"closed"):
+                return b"resolved"
+            if s in (b"parked", b"wontfix"):
+                return b"parked"
+            return b"open"
+    return b""
+
+
+def history(path, gitdir):
+    """Every commit that touched the ticket, oldest first, with the status it had then."""
+    if not gitdir:
+        return "[]"
+    log = _git(["log", "--reverse", "--format=%H %at", "--", path])
+    lines = log.split(b"\n")
+    lines.pop()  # read stops at the last newline: an unterminated last line is never read
+    out = []
+    for line in lines:
+        sha, _, at = line.strip(b" \t").partition(b" ")
+        at = at.strip(b" \t")
+        if not sha:
+            continue
+        st = show_status(_git(["show", (sha.decode("ascii", "surrogateescape") + ":./" + path)]))
+        if not st:
+            continue
+        out.append('{"t":%s,"status":"%s"}' % (at.decode("utf-8", "surrogateescape"), st.decode("ascii")))
+    return "[%s]" % ",".join(out)
+
+
+def build_json(feature, folder, gitdir, err):
+    """The page data, as text; raises Stop when the status reader fails (the bash set -e exit)."""
+    core_out = _Text()
+    rc = status.run([feature, "--json"], core_out, err)
+    if rc != 0:
+        raise Stop(rc)
+    core = core_out.text.rstrip("\n")
+    if core.endswith("}"):
+        core = core[:-1]
+    details = []
+    for path in tickets.ticket_files(folder):
+        name = path.rsplit("/", 1)[-1]
+        if name.endswith(".md") and name != ".md":
+            name = name[:-3]
+        label = name.split("-", 1)[0]
+        details.append('"%s":%s,"history":%s}' % (label, extras(path), history(path, gitdir)))
+    generated = time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())
+    return '%s,"generated":"%s","details":{%s}}' % (core, generated, ",".join(details))
+
+
+def page(template, data, refresh):
+    """The template with the refresh tag and the data put in, as the bash render awk writes it."""
+    records = template.split(b"\n")
+    if template.endswith(b"\n"):
+        records.pop()
+    elif not template:
+        records = []
+    data = data.replace(b"\n", b"")  # getline reads the data line by line and prints them joined
+    out = []
+    for rec in records:
+        if b"<!--__REFRESH__-->" in rec:
+            rec = rec.replace(b"<!--__REFRESH__-->", refresh, 1)
+        p = rec.find(b"__FLOW_DATA__")
+        if p >= 0:
+            out.append(rec[:p] + data + rec[p + 13:] + b"\n")
+        else:
+            out.append(rec + b"\n")
+    return b"".join(out)
+
+
+class View:
+    def __init__(self, feature, folder, template, out_path, gitdir, out, err):
+        self.feature, self.folder, self.template = feature, folder, template
+        self.out_path, self.gitdir, self.out, self.err = out_path, gitdir, out, err
+
+    def render(self, watch):
+        fd, tmp = tempfile.mkstemp()  # like mktemp: on a failure below it is left behind, as in bash
+        os.close(fd)
+        data = build_json(self.feature, self.folder, self.gitdir, self.err)
+        data = data.encode("utf-8", "surrogateescape").replace(b"<", b"\\u003c")
+        with open(tmp, "wb") as handle:
+            handle.write(data)
+        parent = os.path.dirname(self.out_path.rstrip("/")) or "."
+        try:
+            os.makedirs(parent, exist_ok=True)
+            with open(tmp, "rb") as handle:
+                data = handle.read()
+            with open(self.template, "rb") as handle:
+                template = handle.read()
+            with open(self.out_path + ".tmp", "wb") as handle:
+                handle.write(page(template, data, REFRESH if watch else b""))
+            target = self.out_path
+            if os.path.isdir(target):  # mv moves the file into a directory of that name
+                target = os.path.join(target, os.path.basename(self.out_path + ".tmp"))
+            os.replace(self.out_path + ".tmp", target)
+        except OSError as e:
+            self.err.write("flow-view: %s\n" % e)
+            raise Stop(1)
+        os.remove(tmp)
+
+    def open_page(self, opening):
+        if not opening or os.environ.get("FLOW_NO_OPEN", "") == "1":
+            return
+        sys.stdout.flush()
+        if shutil.which("open"):
+            rc = subprocess.call(["open", self.out_path])
+            if rc != 0:
+                raise Stop(rc)
+        elif shutil.which("xdg-open"):
+            subprocess.call(["xdg-open", self.out_path], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+
+
+def pause(value, err):
+    """sleep "$FLOW_WATCH_SECONDS": a number with an optional s, m, h or d suffix."""
+    m = _SLEEP.match(value)
+    if not m:
+        err.write("sleep: invalid time interval '%s'\nTry 'sleep --help' for more information.\n" % value)
+        raise Stop(1)
+    time.sleep(float(m.group(1)) * _UNITS[m.group(2)])
+
+
+def _pwd():
+    """The working directory as bash sees it: $PWD when it names this directory, else the real path."""
+    pwd = os.environ.get("PWD", "")
+    try:
+        if os.path.isabs(pwd) and os.path.samefile(pwd, "."):
+            return pwd
+    except OSError:
+        pass
+    return os.getcwd()
+
+
+def script_dir(script):
+    """What $(cd "$(dirname "$0")" && pwd) prints: the script's folder, logical, not resolved."""
+    d = os.path.dirname(script) or "."
+    return os.path.normpath(os.path.join(_pwd(), d))
+
+
+def run(argv, out, err, here):
+    """Write what the bash script would to out and err, and return its exit code."""
+    try:
+        return _run(list(argv), out, err, here)
+    except Stop as stop:
+        return stop.code
+
+
+def _run(argv, out, err, here):
+    def usage():
+        err.write(USAGE + "\n")
+        raise Stop(2)
+
+    if not argv or argv[0] == "":
+        usage()
+    feature = argv[0]
+    rest = argv[1:]
+    watch, opening, out_path = False, True, ""
+    while rest:
+        arg = rest.pop(0)
+        if arg == "--watch":
+            watch = True
+        elif arg == "--no-open":
+            opening = False
+        elif arg == "--out":
+            out_path = rest.pop(0) if rest else ""
+            if out_path == "":
+                usage()
+        else:
+            usage()
+
+    folder = "%s/%s/%s" % (os.environ.get("FLOW_DIR") or "plans", feature, os.environ.get("FLOW_TICKETS") or "tasks")
+    if not os.path.isdir(folder):
+        err.write("no ticket folder: %s\n" % folder)
+        return 2
+    template = here + "/flow-view.html"
+    if not os.path.isfile(template):
+        err.write("missing %s\n" % template)
+        return 2
+
+    gitdir = os.fsdecode(_git(["rev-parse", "--absolute-git-dir"]).rstrip(b"\n"))
+    if out_path == "":
+        base = gitdir if gitdir else (os.environ.get("TMPDIR") or "/tmp")
+        out_path = "%s/flow-%s.html" % (base, feature)
+
+    view = View(feature, folder, template, out_path, gitdir, out, err)
+    view.render(watch)
+    out.write("wrote %s\n" % out_path)
+    view.open_page(opening)
+
+    if watch:
+        out.write("watching, press Ctrl-C to stop\n")
+        while True:
+            rc = status.run([feature, "--next"], _Null(), _Null())
+            if rc == 10:
+                view.render(False)
+                out.write("feature complete, final page written\n")
+                break
+            view.render(True)
+            pause(os.environ.get("FLOW_WATCH_SECONDS") or "3", err)
+    return 0
+
+
+def main(argv=None, here=None):
+    argv = sys.argv[1:] if argv is None else argv
+    here = script_dir(sys.argv[0]) if here is None else here
+    sys.stdout.flush()
+    try:
+        return run(argv, status._Bytes(sys.stdout.buffer), status._Bytes(sys.stderr.buffer), here)
+    except KeyboardInterrupt:  # Ctrl-C in --watch: bash dies of the signal and prints nothing
+        return 130

feature_flow_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,293 @@
+Metadata-Version: 2.4
+Name: feature-flow-cli
+Version: 0.1.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
+Project-URL: Source, https://github.com/hamilton-sky/feature-flow
+Keywords: claude-code,codex,agents,workflow,tickets
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# Feature Flow
+
+**A ticket-graph workflow for coding agents.** Works with Claude Code and Codex.
+
+[![tests](https://github.com/hamilton-sky/feature-flow/actions/workflows/tests.yml/badge.svg)](https://github.com/hamilton-sky/feature-flow/actions/workflows/tests.yml)
+
+Plan a feature as a graph of small tickets, then build them in the session you are already in. One command, `/feature-flow`, does both. Every ticket is built by one fresh subagent and checked by another that never saw the builder's reasoning. A script, not the agent, decides the order of the steps, runs the build and tests, and watches for work that weakens the checks, and the whole run has limits.
+
+One skill, 2 agent roles, a Python conductor, 4 Python scripts, an installer for both agents, a demo and a test suite. All of it is Python (standard library only), so it runs on Linux, macOS and Windows. MIT licensed.
+
+- [Quick start](#quick-start) · [How a ticket flows](#how-a-ticket-flows) · [The skill and the roles](#the-skill-and-the-roles) · [Plans and tickets](#plans-and-tickets)
+- [See the graph](#see-the-graph) · [Long features and handoff](#long-features-and-handoff) · [What is tested](#what-is-tested) · [Upgrading](#upgrading) · [Caution](#caution)
+
+## Quick start
+
+You need `git` and `python3` (3.9 or later, standard library only), and Claude Code or Codex. No `bash` or `awk` is needed to run feature-flow: every script is Python. On Windows use `python` where this page says `python3`.
+
+```bash
+git clone https://github.com/hamilton-sky/feature-flow.git
+cd feature-flow
+
+python3 install.py /path/to/your/repo                  # for Claude Code
+python3 install.py /path/to/your/repo --agent codex    # for Codex
+python3 install.py /path/to/your/repo --agent all      # both, side by side
+
+# `bash install.sh ...` still works on Linux and macOS: it only runs install.py
+```
+
+Without a clone, once the package is on PyPI (it is not published yet), the same installer runs from it:
+
+```bash
+uvx feature-flow-cli install /path/to/your/repo --agent all   # or: pipx run feature-flow-cli install ...
+```
+
+The package puts a `feature-flow` command on your PATH with `install`, `status <feature>` and `view <feature>`. It installs the same files, byte for byte, as `install.py` from a clone.
+
+Then, in your repo, in the agent:
+
+| | Claude Code | Codex |
+|---|---|---|
+| Plan a feature (no plan yet) | `/feature-flow csv-export` | `$feature-flow csv-export` |
+| Build its tickets (a plan exists) | `/feature-flow csv-export` | `$feature-flow csv-export` |
+| The same, asking nothing | `/feature-flow csv-export auto` | `$feature-flow csv-export auto` |
+| Watch the graph, animated | `/feature-flow csv-export show` | `$feature-flow csv-export show` |
+
+The same command plans when `plans/csv-export/` does not exist yet and builds when it does. Commit the plan before you build it.
+
+Try the graph first, with no setup and no agent: `bash examples/demo.sh --open`.
+
+### What the installer does
+
+| | Claude Code (`--agent claude`, the default) | Codex (`--agent codex`) |
+|---|---|---|
+| The skill goes to | `<repo>/.claude/skills/` (`--user`: `~/.claude/skills/`) | `<repo>/.agents/skills/` (`--user`: `~/.agents/skills/`) |
+| Roles go to | `<repo>/.claude/agents/` | `<repo>/.agents/flow-roles/`, put in front of each subagent's prompt |
+| Scripts go to | `<repo>/scripts/` | `<repo>/scripts/` |
+| Guides, roles and the conductor go to | `<repo>/.feature-flow/` | `<repo>/.feature-flow/` |
+
+Next to the `feature-flow` skill it installs `architect-review` and `automation-design`. The installer never deletes anything. A file that already exists and differs is kept and reported; `--force` replaces it. `--dry-run` shows what would change and writes nothing. `CLAUDE_HOME` and `AGENTS_HOME` move the user folders. With `--user` the skill goes to the user folder, but the scripts and `.feature-flow/` stay in the repo, because the skill runs them from there.
+
+The Claude Code skill is `skills/feature-flow/`. The Codex skill is written by hand in `adapters/codex/feature-flow/`, with an `agents/openai.yaml` that sets `allow_implicit_invocation: false`, so it runs only when you name it. The steps are the same; only the way a subagent is started differs. Your own `AGENTS.md` and `CLAUDE.md` are never touched.
+
+## How a ticket flows
+
+```
+ smoke command (script): is the base healthy?   no ─► stop, spend nothing
+        │ yes
+        ▼
+ pick ticket ─► builder subagent: claim, build, prove it (run fresh, read the output), commit
+                                              │
+                                              ▼
+ gate (script):  Build, Test, Lint from commands.md           fail ─┐
+                                              │ pass                │
+                                              ▼                     │
+ floor guard (script, no AI):                                       │
+   tests skipped or deleted? checks silenced? empty catches?        │
+   thresholds lowered? lint/test/CI config edited?             fail ─┤
+   plan touched beyond own Status + Answer + appended lines?        │
+                                              │ clean               │
+                                              ▼                     │
+ fresh reviewer subagent: sees only the ticket + diff,              │
+ re-runs every Done when                                      FAIL ─┤
+                                              │ PASS                ▼
+                                              ▼        findings written into the ticket,
+                                     next ticket       reopened, built again (3 rounds max)
+```
+
+`scripts/flow.py` is the conductor. The session asks it `next`, and it answers with one line: `BUILD`, `REVIEW`, `DONE`, `STOP` or `HANDOFF`. It prints the full prompt for each subagent from runtime-neutral guides, so the session never writes one itself.
+
+**What the script checks and what it trusts.** The conductor verifies the build from the repo: the ticket file must say `resolved`, the tree must be clean and committed, and it runs the gate and the floor guard itself. It also checks that the reviewer changed no tracked file and made no commit. The review verdict is different: the reviewer's reply is relayed by the session, which saves it to a file and hands it to `flow.py verdict`. The script reads `REVIEW: PASS` or `REVIEW: FAIL` from that reply; it cannot prove the session passed it on unedited.
+
+## The skill and the roles
+
+| Skill | What it does |
+|---|---|
+| `feature-flow` | **Plan:** writes `plans/<feature>/` with a spec, a map, commands, learnings and tickets, shows you the graph, and waits for a yes. **Build:** runs the tickets one by one, a builder and a reviewer subagent each, with `flow.py` deciding every step. **Show:** the animated ticket graph and a summary of what is ready and what blocks the finish. |
+| `architect-review` | Architecture review of a file, diff or feature, with severity rated findings. Reads `CLAUDE.md` or `AGENTS.md` for the project's own rules. |
+| `automation-design` | Blueprint for an automation pipeline. Hands off to `feature-flow` for the plan. |
+
+| Role | Tools | Job |
+|---|---|---|
+| `ticket-builder` | Read, Glob, Grep, Edit, Write, Bash | Builds one ticket by the build guide in its prompt. |
+| `ticket-reviewer` | Read, Glob, Grep, Bash (no Edit, no Write) | Reviews one ticket by the review guide in its prompt and ends with `REVIEW: PASS` or `REVIEW: FAIL`. |
+
+In Claude Code the reviewer's tool list is enforced, so it cannot edit. A Codex subagent cannot be limited that way, so there the reviewer works from its instructions, and the conductor stops the run if it changed anything.
+
+The guides in `guides/` (installed to `.feature-flow/guides/`) hold the protocol: how to build, review, plan and show. The skill holds only what differs per agent.
+
+## Plans and tickets
+
+```
+plans/
+└── csv-export/
+    ├── spec.md          what and why
+    ├── map.md           destination, the bar, decisions so far     (workers append only)
+    ├── commands.md      build, test, lint, smoke commands           (frozen once approved)
+    ├── learnings.md     traps workers found                         (workers append only)
+    └── tasks/
+        ├── 01-types.md
+        ├── 02-service.md
+        └── 03-acceptance.md
+```
+
+`commands.md` and `learnings.md` are separate from the map because they follow different rules. Commands are approved by a human and read by the scripts, so they are frozen. Learnings grow with every ticket, so they are append only and a human prunes them (`--check` warns past 40 lines). The map stays short.
+
+One markdown file per ticket in `plans/<feature>/tasks/NN-slug.md`:
+
+```
+# Add the retry policy to the job runner
+
+Type: task                 task | settle | convert
+Status: open               open | claimed | resolved | parked
+Blocked by: 01, 02         or —
+Test first: yes            yes | no
+Floor: allow config        optional, only when a human decides the guard may let it through
+
+...what to do and why...
+
+## Not in this ticket
+## Done when                 commands and the results they print
+## Reference
+## Answer                    Built, Proof, Decisions, Shortcuts taken, Review fixes, For later tickets
+```
+
+- **Order comes from `Blocked by`**, not from numbers. A ticket is *ready* when it is open and every ticket it is blocked by is resolved. Lowest number wins.
+- **Status lives only in the ticket files.** `map.md` never repeats it.
+- **The Answers are the handoff between subagents.** The next builder reads the Answers of the tickets it depends on.
+- `settle` tickets record a decision. `convert` tickets migrate something and must be safe to run twice.
+- **A worker may change only** its own Status line and Answer, lines appended to `map.md` and `learnings.md`, and the code the ticket calls for. Rewriting its own Done when, editing another ticket, or touching `commands.md` fails the guard.
+- `Floor:` categories: `skip`, `suppress`, `empty-catch`, `test-delete`, `threshold`, `config`, `ticket-edit`, `commands-edit`. The line is read from the ticket as it was before the work started, so a worker cannot excuse itself.
+- The guard needs the plan to be tracked by git. If you keep tickets in an ignored folder, it cannot see changes to them.
+- The commands in `commands.md` run with nobody watching and must exit non zero on failure.
+
+## See the graph
+
+```bash
+python3 scripts/flow-view.py csv-export            write the page and open it
+python3 scripts/flow-view.py csv-export --watch    keep it updating while tickets are built
+bash examples/demo.sh --open                    try it on a made up project, no setup needed
+```
+
+One self contained HTML file: no server, no libraries, no network, light and dark. It is written to `.git/flow-<feature>.html`, so it never dirties the tree (`--out FILE` writes it elsewhere).
+
+```
+  01 types ──► 02 service ──► 04 acceptance        ● resolved  ◉ ready (pulses)
+        └────► 03 wire ──────────┘                 ◌ being worked (spins)  ○ waiting
+  ▶ replay ──●──────●─────○──────────   drag to scrub through the run
+```
+
+- **Layered left to right**, so the order of work is visible. Dashes flow along the edges into tickets that are ready to start.
+- **Replay** plays the run back from git history: tickets turn green in the order they resolved, and a ticket sent back by the gate, the guard or the reviewer flashes red.
+- **Hover or click** a ticket for its blockers, Done when, Answer, and the rounds it was sent back.
+- **Keys:** space plays or pauses, the arrows step, End shows now, `t` switches theme. Reduced motion is respected.
+- **Safe by construction:** ticket text comes from files an agent wrote, so it is escaped when embedded and only ever inserted as text.
+- `flow-status.py <feature> --json` prints the same data for other tools. Mermaid (`--mermaid`) remains the choice for pull requests, because GitHub renders it.
+
+## Long features and handoff
+
+A session's context fills up, so the flow moves to a fresh session every few tickets. After `FLOW_TICKETS_PER_SESSION` tickets (default 4) pass review, `next` prints a `HANDOFF` line instead of the next ticket, for example `HANDOFF /feature-flow csv-export`. The session stops and tells you to open a new session and type that line. The new session picks up exactly where the last one stopped. Set `FLOW_TICKETS_PER_SESSION=0` to never hand off.
+
+- **One owner at a time.** `start` gives the session a token, and every later call must carry it, so two sessions can never drive the same feature. `HANDOFF` and `DONE` release it.
+- **Resuming after a closed session.** If a session ended without `HANDOFF` (you closed it, it crashed, it ran out of budget), the feature is still owned by it, and a new session stops and says so. Once you are sure the old session is gone, answer yes when the new session asks, or start it with `FLOW_TAKEOVER=1`. With `auto` the skill never takes over on its own.
+- **Relay mode.** `FLOW_RELAY=1` hands off after every build and every review, so each phase gets a session of its own.
+- **Nobody needs to watch.** With `auto` the skill asks nothing, and a Claude Code cloud session keeps working while you are away. You only come back to type the `HANDOFF` line.
+
+The state lives in `.feature-flow/state/` (the state, a log of every step, and the last review reply). That folder ignores itself, so it never shows up in `git status`, and a normal Codex session can write it, which it cannot do under `.git`.
+
+### Commands and settings
+
+```bash
+python3 scripts/flow.py <feature> start|next|prompt|verdict <file>   the conductor (the skill runs it)
+python3 scripts/flow-status.py <feature>                  table of tickets and which are READY
+python3 scripts/flow-status.py <feature> --next           path of the next ready ticket (exit 10 = done, 11 = stuck)
+python3 scripts/flow-status.py <feature> --counts         one line of counts
+python3 scripts/flow-status.py <feature> --check          cycles, missing blockers, missing Done when, unordered mentions
+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
+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
+```
+
+The commands in `commands.md` run through `bash -c` on Linux and macOS and through the system shell (`cmd.exe`) on Windows, so write them for the platform your team uses, or call `python` as in the examples.
+
+`flow-status.py` also understands the `.scratch/<feature>/issues/` layout and the statuses `done`, `ready-for-agent`, `ready-for-human` and `closed`: `FLOW_DIR=.scratch FLOW_TICKETS=issues`.
+
+| Variable | Default | Meaning |
+|---|---|---|
+| `FLOW_TICKETS_PER_SESSION` | `4` | tickets per session before `HANDOFF`; `0` never hands off |
+| `FLOW_RELAY` | `0` | `1` hands off after every build and every review |
+| `FLOW_TAKEOVER` | unset | `1` lets `start` take a feature over from a session that is gone |
+| `FLOW_MAX_RETRIES` | `2` | builds or reviews per step before the run stops |
+| `FLOW_MAX_REVIEW_ROUNDS` | `3` | times a ticket may be sent back before the run stops |
+| `FLOW_GATE` | `on` | `off` skips Build, Test and Lint after each ticket |
+| `FLOW_SMOKE` | the `Smoke:` line of `commands.md` | command run before every ticket; the run stops if it fails |
+| `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 |
+
+The run also stops on its own after a number of steps that grows with the ticket count, so a loop of failures cannot go on forever.
+
+## What is tested
+
+| Path | Tested |
+|---|---|
+| Claude Code | The offline suite, and **one real run of the bar**: the two-ticket demo in two `/feature-flow hello auto` sessions with one `HANDOFF` between them, each ticket built by a builder subagent and passed by a reviewer subagent, with all 16 acceptance checks ok. It used about 23k output tokens and 2M cached input tokens on Sonnet. |
+| Codex | The install, offline, in CI on Linux and macOS. A probe in the Codex app showed that subagents with separate contexts work and that a reviewer's verdict reaches the session. The full flow is **not yet tested with a real run**. |
+| Claude Code on the web | Documented, untested: commit `.claude/`, `scripts/` and `.feature-flow/` into the repo, because cloud sessions read only the repo's `.claude/`. |
+| Copilot, Gemini CLI, Cursor | Not tested. Some read `.agents/skills`, so `--agent codex` may already work. |
+
+### Trying it by hand
+
+```bash
+bash tests/smoke-real.sh --prepare /tmp/hello-try                    # the demo project, for Claude Code, no model is called
+FLOW_AGENT=codex bash tests/smoke-real.sh --prepare /tmp/hello-codex # the same, for Codex
+```
+
+Then `cd` into it, start the agent and type `/feature-flow hello` (Codex: `$feature-flow hello`).
+
+## Tests
+
+```bash
+bash tests/run.sh
+python3 -m unittest discover -s tests/py
+```
+
+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, and the acceptance harness. 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 (once with `mawk`, once with `gawk`) 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`. `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`.
+
+`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`.
+
+## Upgrading
+
+Earlier versions had seven skills and an unattended loop. The five flow skills are gone, and `/feature-flow` replaces them:
+
+- `plan-feature` → `/feature-flow <feature>` before a plan exists.
+- `/next-phase` and `/review-ticket` → `/feature-flow <feature>`, which runs a builder and a fresh reviewer subagent for every ticket.
+- `show-flow` → `/feature-flow <feature> show`.
+- `/run-flow` and `scripts/auto-flow.sh` → `/feature-flow <feature> auto`, with a `HANDOFF` every few tickets. There is no cost log any more.
+
+The installer never deletes the old skill folders, but it names any it finds. Delete them from `.claude/skills/` or `.agents/skills/` yourself.
+
+## Releasing to PyPI
+
+The package is `feature-flow-cli` (the shorter `feature-flow` is likely refused by PyPI as too close to the existing `featureflow`). Its version is `__version__` in `feature_flow/__init__.py`. To release: bump it, then `python3 -m build` and `python3 -m twine upload dist/*` with a PyPI API token, or publish from a GitHub Actions workflow set up as a PyPI trusted publisher. Nothing in this repo uploads on its own.
+
+## Caution
+
+The builder subagent has edit and shell access and commits after each ticket. Each ticket costs at least two subagents. Build on a branch you can throw away. Ignore build output in `.gitignore`, because the conductor stops if the tree is dirty after a ticket. The gate runs your Build, Test and Lint commands with no time limit. The floor guard is pattern matching: it can miss things and it can raise false alarms, and `Floor: allow` is the release valve. The run stops on its own when a ticket stays unresolved, when the smoke test or the gate keeps failing, when a ticket keeps failing review, or when it reaches its step limit.
+
+## License
+
+MIT. See `LICENSE`.

feature_flow_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,44 @@
+feature_flow/__init__.py,sha256=gFNdla6ftW3fdGJA6c5vz26qxAHgUWrDdYS0ERE7cBc,86
+feature_flow/__main__.py,sha256=A4WYj11KI9rxNVajkbcbs4eiWrK3-ou6gbAnYyECjgc,137
+feature_flow/checks.py,sha256=fkLiGai7VcrRAjn_opCj0SkSNQY16MhGwQWIjfraVnA,2344
+feature_flow/cli.py,sha256=oLJQ7WTx043ZApUHqKNP29K8OqeKkwxDkCmIn2rP2J8,1500
+feature_flow/command.py,sha256=dhcQ2NtP_LPJwaPZQSEPoFJWmZS8ITjpdK1EzG_-a6M,1598
+feature_flow/conductor.py,sha256=OLLStMRejHbs0Dge8IIMpMxRbErB8Rey7JmsbOPC4wA,12663
+feature_flow/floorguard.py,sha256=Usg2KmN-qAg1dD_VaLzkwFxZHXWGCMW4kxY5F3mwFms,13064
+feature_flow/gate.py,sha256=Rq0YOJjfqNhgSAoSMEmnTBuuVtNkQ03c1R7ZVf7ALKE,3661
+feature_flow/git.py,sha256=vacYCI6iuEiwANyi_3jjV5XUQAtX7LwL-8zatFEkX0U,1515
+feature_flow/install.py,sha256=a1Wa0-qEs1hBdwBGm3qgqkgHn8bN3Mn8vC2-MSpszsg,14762
+feature_flow/prompts.py,sha256=cdJpkaUmOq3oEryar5DdvuRLnGEmMwL6X7zwCT90vms,2611
+feature_flow/state.py,sha256=9xQTapyUm8sjtndVowctCUbKWmwKSE9qQvgMI5ZOV1g,2530
+feature_flow/status.py,sha256=L1tYnirK_Fv--8v2jWm8V8Ao3FCdR2YWB2JpW-Uyqps,8624
+feature_flow/tickets.py,sha256=VplR9tRHriVtGAKrKawoevaFjjijSHnT9FNNcyCXurw,6073
+feature_flow/view.py,sha256=d0EW4WM3c5C1jcd50AiCUBPUr_AjosMDMvRttTtHPt0,11668
+feature_flow/_bundle/adapters/codex/feature-flow/SKILL.md,sha256=mJKBaCXg3k9aQNuvJQazDRs1aNCurcZZfEofwP2HIiU,4918
+feature_flow/_bundle/adapters/codex/feature-flow/agents/openai.yaml,sha256=mDOVln4eJrylnPTaU5SB9CbDw9AuZwKAds1NIEUnrEQ,251
+feature_flow/_bundle/agents/ticket-builder.md,sha256=rpmcUKkaI0tJQ9_4cx1A0w2n0EsrpM8TkRpqxiNtLGA,1296
+feature_flow/_bundle/agents/ticket-reviewer.md,sha256=EWryy2TdIrBh5yF6euyW7ML6kZOQXxcVTOc1QrijoEk,826
+feature_flow/_bundle/guides/build.md,sha256=8zVIjx6J5jvy8FiKcf7Mv-zggO-dy1-sFfiYaFdkNPA,9319
+feature_flow/_bundle/guides/plan.md,sha256=8F2JCnk3nui4m874Y2GsyTyms_eyd1ABJtBYJDpg-fI,7615
+feature_flow/_bundle/guides/review.md,sha256=FudfVl4wrA1OQY2BP5w5mShgeianyE9LmDux6PxOMME,6151
+feature_flow/_bundle/guides/show.md,sha256=6zRvBc1jWSknSaCRX-izQSs_maSTohspTnY6PaCoCFI,1801
+feature_flow/_bundle/guides/templates/commands.md,sha256=w153NgDUwzQLXknv-cyOsmgq33q4pWWZos4_pwnBDL8,648
+feature_flow/_bundle/guides/templates/learnings.md,sha256=dTCqkBSTU7YHVg65wWqM6b51hG9o-ztxxaLJFz0hqbM,335
+feature_flow/_bundle/guides/templates/map.md,sha256=abE6ExRmr1ShcuclX63iRqrXBrF3-jYBqEOveoc8siY,983
+feature_flow/_bundle/guides/templates/spec.md,sha256=S7F-b52bPHfoWPBhuIirmnvqnj7yzyaSMMHD1C2ACpE,1335
+feature_flow/_bundle/guides/templates/ticket.md,sha256=KuaPffDpLVmp5p29PaUQPamrPem5oqt67DBUxBDLWtE,942
+feature_flow/_bundle/guides/templates/ui-mockup.md,sha256=CEGYgatTk14Kc52K5_xuXN-utZc5S91cEdU4pagIYJE,1978
+feature_flow/_bundle/scripts/floor-guard.py,sha256=06IxOCYIjZXcC8JiWwIi-YIjY27aOlnv6sWDjzYuWys,493
+feature_flow/_bundle/scripts/flow-status.py,sha256=QId55aQgqLkM8EIoMGYPFZPv3ZxJmWZaG-sAlyGcJ0k,537
+feature_flow/_bundle/scripts/flow-view.html,sha256=L5T9FzAHeXR3Tvp11JdBpid-mgYAQQQcAj_5_01hKec,27086
+feature_flow/_bundle/scripts/flow-view.py,sha256=wtvDFi-L1HoVywoQ5sreLO_T-VHqjHWxdZV74c3OsXQ,507
+feature_flow/_bundle/scripts/flow.py,sha256=iVIuu1v4iRpfqrgMhnFeP2EICO9YjOC7JhxbpLuDwRU,493
+feature_flow/_bundle/scripts/gate.py,sha256=6BlMCqRrFp2EEoN_k0XI8yN4VwuEdKI1fFVwCACTt84,467
+feature_flow/_bundle/skills/architect-review/SKILL.md,sha256=RcxmTLFo6oKz0E0WzZbEOSvMIXQfVXSTBuaf2PKg9ow,6824
+feature_flow/_bundle/skills/automation-design/SKILL.md,sha256=LGNQ70Fi7j0ggUWCGBjEVAqZ3PS7F5FfD9_KiongG_s,10332
+feature_flow/_bundle/skills/feature-flow/SKILL.md,sha256=RH8Mny7MsvUxPKkT2R1_ucM2sw-gO11TRgnNIt4EBwM,4514
+feature_flow_cli-0.1.0.dist-info/licenses/LICENSE,sha256=DIRvhlH8EulEUOYQxKDFFiimJrlVT5-kCKxQIgi2m7c,1073
+feature_flow_cli-0.1.0.dist-info/METADATA,sha256=QFQdTM1AAeRW3csiN3GliVVtWBWyGKVUU0hg74BQ5C4,21683
+feature_flow_cli-0.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+feature_flow_cli-0.1.0.dist-info/entry_points.txt,sha256=R2gfzSs0axu97MVIhWN3UpEASyome9CYTQWzhwR7NaQ,104
+feature_flow_cli-0.1.0.dist-info/top_level.txt,sha256=tf9cs_th2oqfDY4tXB9SFMr3IWnMuGwH5DHe5mbz3eU,13
+feature_flow_cli-0.1.0.dist-info/RECORD,,

feature_flow_cli-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+