@jawache/flow 0.1.2 → 0.3.0

package/docs/user/migrations/0.3.0.md

@@ -0,0 +1,289 @@
+---
+summary: "upgrade to 0.3.0 from 0.2.3"
+---
+
+# Upgrade to 0.3.0
+
+[All guides](./index.md)
+
+0.3.0 parses each shell command as bash before it judges it, and loads a config more strictly. Most repos re-run `flow init`, add one line to `.githooks/pre-commit`, and run `flow test`. A repo with its own command rules or its own checks may need more of section 2.
+
+- **Command rules.** A `banCommands` entry, a `substitutionInProse` head and a `justfile` pack `recipes` key each name a command in words, such as `"git push --force"`, not a regex. Each is compared with the program and arguments of one command at a time. `matchHeredocs` is removed.
+- **The parse.** A check of your own reads it as `ctx.commands`. The old `tokenizeCommand` and `gitInvocations` are removed.
+- **The load.** A guardrail with no block case, an empty `.on()` or `.ignore()`, and a breadcrumb with both `.text(…)` and `.file(…)` no longer load.
+- **The hooks and the gate.** They run the repo's own `@jawache/flow` package first, then the `flow` on the `PATH`.
+- **Uninstall.** `flow uninstall` takes flow's wiring off a repo, and the `flow` pack refuses it when an agent runs it.
+- **A subagent's hand-back.** `flow init` registers Claude Code's `SubagentStop` hook, so a turn-end rule runs when a subagent hands back. A breadcrumb bound at turn-end is now shown.
+
+## 1 · Install 0.3.0
+
+```sh
+npm i -D @jawache/flow@0.3.0    # when flow is a dev dependency of the repo
+npm i -g @jawache/flow@0.3.0    # when `flow` is installed globally
+```
+
+With a dev dependency, type each `flow` command on this page as `npx flow`.
+
+## 2 · Required changes
+
+### 2.1 · Re-run `flow init`
+
+**Applies if:** the Claude Code settings file has a hook whose command is the bare `flow hook <event>`. Run `grep -n '"flow hook ' .claude/settings.json ~/.claude/settings.json`; a line printed means yes. With flow as a dev dependency and no `flow` on the `PATH`, `flow status` also prints a red `binary` line naming the hooks.
+
+**Change:** run `flow init`. It never writes over `flow.config.ts` or `.githooks/pre-commit`. It rewrites each bare registration in place to the command that runs the repo's own package first:
+
+```sh
+f="$CLAUDE_PROJECT_DIR/node_modules/@jawache/flow/dist/flow.mjs"; [ -f "$f" ] && exec node "$f" hook <event>; exec flow hook <event>
+```
+
+When the repo's `package.json` lists `@jawache/flow`, the hooks now go in the repo's own `.claude/settings.json`, and `flow init` rewrites the bare commands in `~/.claude/settings.json` too, so each hook runs once. Commit the repo's `.claude/settings.json`.
+
+**Why:** the bare command runs only the `flow` on the `PATH`, so a repo with flow only as a dev dependency answers no hook.
+
+### 2.2 · Re-run `flow init` to register `SubagentStop`
+
+**Applies if:** `flow status` prints a red `hooks` line that says ``does not call flow for SubagentStop — re-run `flow init` ``. An init before 0.3.0 wrote five registrations, and `SubagentStop` was not one.
+
+**Change:** run `flow init`. It adds the one registration and keeps every other key in the settings file:
+
+```
+  + ~/.claude/settings.json — SubagentStop
+```
+
+The new entry runs the same command as the other five, with `subagent-stop` as the event. With flow as a dev dependency, the file is the repo's `.claude/settings.json`: commit it.
+
+**Why:** Claude Code sends `Stop` only when the main chat hands back. A subagent's hand-back sends `SubagentStop`, and without it no turn-end rule runs for a subagent.
+
+### 2.3 · Add the repo-first line to `.githooks/pre-commit`
+
+**Applies if:** `grep -n 'node_modules/@jawache/flow/dist/flow.mjs' .githooks/pre-commit` prints nothing. `flow init` does not change an existing pre-commit hook.
+
+**Change:** add this line above `exec flow hook commit`:
+
+```sh
+f="$PWD/node_modules/@jawache/flow/dist/flow.mjs"; [ -f "$f" ] && exec node "$f" hook commit
+```
+
+The end of the hook then reads:
+
+```sh
+f="$PWD/node_modules/@jawache/flow/dist/flow.mjs"; [ -f "$f" ] && exec node "$f" hook commit
+exec flow hook commit
+```
+
+**Why:** without it, the gate runs only the `flow` on the `PATH`. A repo with flow only as a dev dependency then refuses every commit with `flow: not found`, and a repo with both runs the global version instead of the one in its lockfile.
+
+### 2.4 · Give every guardrail a block case
+
+**Applies if:** `flow status` reports a `no-block-cases` refusal. A guardrail whose `.test(…)` holds only `pass` cases, or no cases at all, no longer loads. In 0.2.3, a guardrail with no cases was refused as `no-cases`, and one with pass cases alone loaded.
+
+**Change:** add one input the rule must refuse to `.test({ block: [...] })`:
+
+```ts
+// before
+.test({ pass: ["drizzle-kit generate"] })
+// after
+.test({ pass: ["drizzle-kit generate"], block: ["drizzle-kit drop"] })
+```
+
+**Why:** a rule with no block case has never been seen to refuse anything, so nothing proves it catches what it is for.
+
+### 2.5 · Remove an empty `.on()` or `.ignore()`, and choose `.text(…)` or `.file(…)`
+
+**Applies if:** `flow status` reports `empty-scope` or `double-prose`. `empty-scope` is an `.on()` or `.ignore()` given no globs, on an entry or an override, including a spread list that turns out empty, such as `.on(...files)`. `double-prose` is a breadcrumb, or an override of one, that says both `.text(…)` and `.file(…)`.
+
+**Change:** for `empty-scope`, delete the call, or give it at least one glob. For `double-prose`, keep one of the two. In 0.2.3, `.text(…)` was the one shown.
+
+**Why:** an empty `.on()` scoped the entry to nothing, so it never fired; and a breadcrumb shows one prose, so the second was ignored.
+
+### 2.6 · Rename `no-cases` to `no-block-cases` in code that reads refusal codes
+
+**Applies if:** `git grep -n "no-cases"` prints a line outside `node_modules`.
+
+**Change:** `"no-cases"` → `"no-block-cases"`. `REFUSAL_CODES` also gains `empty-scope` and `double-prose`.
+
+**Why:** the refusal now covers a guardrail whose cases are all pass cases, not only one with no cases.
+
+### 2.7 · Rewrite each `banCommands` entry in words
+
+**Applies if:** `git grep -n -A3 "banCommands(" -- ':!node_modules'` prints a rule without `wholeLine: true`. Each entry of that rule is now a command in words, not a regex. Two signs show an entry still written as a regex:
+
+- **It refuses to load.** An entry with a backslash, or one that is not one command, such as `(git|hg) push`, stops the config loading. `flow status` and `flow test` print `bad-check-options`.
+- **It loads and matches nothing.** An entry such as `git push.*--force`, `^git push` or `--no-verify` is read as a program and its words. `flow test` fails its block case with `expected a block and the check passed it`.
+
+A refused entry prints:
+
+```
+flow: the config will not load — 1 refusal.
+  bad-check-options: `local.noForcePush` bans `git\s+push\b.*--force`, which is not one command in words. Name a program and the arguments that make it dangerous, such as "git push --force"; a regex goes under `wholeLine: true`.
+```
+
+**Change:** write each entry as the program, then the arguments that make the command dangerous, each a whole word. [banCommands](../checks/ban-commands.md#how-a-command-is-matched) gives the matching rules.
+
+| 0.2.3 pattern | 0.3.0 entries |
+| --- | --- |
+| `(?:^\|[\n;&\|(]\s*)\s*work\s+plan\s+tick\b` | `"work plan tick"` |
+| `\bnpx\s+vitest\b` | `"npx vitest"` |
+| `git\s+push\b.*\s(--force\|-f)(\s\|$)` | `"git push --force"`, `"git push -f"` |
+| `rm\s+-(rf\|fr)\b` | `"rm -rf"` |
+| `(?:drizzle-kit\s+drop\|wrangler\s+d1\s+delete)` | `"drizzle-kit drop"`, `"wrangler d1 delete"` |
+
+```ts
+// before
+.check(banCommands({ ban: ["git\\s+push\\b.*\\s(--force|-f)(\\s|$)"] }))
+// after
+.check(banCommands({ ban: ["git push --force", "git push -f"] }))
+```
+
+- **One entry per alternative.** A pattern with `(a|b)` becomes one entry for each.
+- **Drop what stood around the words.** Separators such as `(?:^|[\n;&|]\s*)`, and `\b`, `\s+` and `.*`, go. The parse finds where each command starts, and each word is compared whole.
+- **One entry for every order.** `"rm -rf"` also refuses `rm -fr build` and `rm -r -f build`, so a pattern listing each order becomes one entry.
+- **No wrapper or assignment in front.** `"sudo rm -rf"` and `"FOO=1 rm -rf"` refuse to load. Write `"rm -rf"`: the parse steps past `sudo`, `env`, `nohup`, `nice`, `time`, `timeout`, `command`, `exec`, `xargs` and a `FOO=1` assignment to the program that runs.
+- **A pattern that spans two commands on purpose** keeps its regex, under `wholeLine: true`. The pattern is then tried against the whole line, less its heredoc bodies:
+
+  ```ts
+  .check(banCommands({ ban: ["curl[^\\n]*\\|\\s*sh\\b"], wholeLine: true }))
+  ```
+
+- **A pattern about a flag's value or about text**, such as a word inside a commit message, is not a command in words. Write a check of your own that reads [`ctx.commands`](../reference/ctx.md#ctxcommands). [How to write your own check](../how-to/write-your-own-check.md) gives the steps.
+
+**Why:** a regex over a command's text read `/usr/local/bin/work plan tick` as no tick, `rm -fr` as no `-rf`, and `work task-list` as `work task`. An entry in words is compared with the program and the arguments the parse found.
+
+### 2.8 · Remove `matchHeredocs`
+
+**Applies if:** `git grep -n matchHeredocs -- ':!node_modules'` prints a line.
+
+**Change:** delete the key from the `banCommands` options. `tsc` reports it as an unknown property, and flow ignores it at run time. A heredoc's body is never matched by `banCommands`, unless a shell reads it as commands. A rule that read a heredoc's body is about text:
+
+- **A backtick in prose,** built with `substitutionInProse(heads)`, becomes the stock check (2.9).
+- **A commit's message,** such as one fed by `git commit -F - <<'EOF'`, is read by `commitMessage(ctx)`.
+- **Any other body** is in the `heredocs` of each command in [`ctx.commands`](../reference/ctx.md#ctxcommands), as `{ body, quoted }`. Read it in a check of your own.
+
+**Why:** an entry in words is a program and its arguments, and a heredoc's body is neither.
+
+### 2.9 · Rewrite each `substitutionInProse` head in words
+
+**Applies if:** `git grep -n substitutionInProse -- ':!node_modules'` prints a line in your config or your own packs.
+
+**Change:** bind `substitutionInProse` as a stock check, and write each head as a command in words. A head is matched the way a `banCommands` entry is:
+
+```ts
+// before
+.check(banCommands({ ban: [substitutionInProse(["notes\\s+add\\b"])], matchHeredocs: true }))
+// after
+.check(substitutionInProse({ heads: ["notes add"] }))
+```
+
+- **A git subcommand,** such as `commit`, goes in `gitSubcommands: ["commit"]`. It is matched after git's own options, so `git -C '/a b' commit` is `commit`.
+- **A head that is not one command in words** stops the config loading:
+
+  ```
+  flow: the config will not load — 1 refusal.
+    bad-check-options: `local.noBacktickInNotes` names the head `notes\s+add\b`, which is not one command in words. Name a program and the arguments that make it record prose, such as "gh pr".
+  ```
+
+[substitutionInProse](../checks/substitution-in-prose.md) lists what is refused and what passes.
+
+**Why:** a head names which command records prose, and that is a program and its arguments, read from the parse as `banCommands` reads it.
+
+### 2.10 · Rewrite the `justfile` pack's `recipes` keys in words
+
+**Applies if:** `git grep -n -A4 "pack(justfile" -- ':!node_modules'` shows a `recipes` map.
+
+**Change:** write each key as a `banCommands` entry in words (2.7):
+
+```ts
+// before
+pack(justfile, { exempt: [], recipes: { "npx vitest\\b": "just test" } }),
+// after
+pack(justfile, { exempt: [], recipes: { "npx vitest": "just test" } }),
+```
+
+`"npx vitest"` refuses `npx vitest run` and `npx --yes vitest`, and passes `npx vitest-preview`. A key still written as a regex stops the config loading:
+
+```
+flow: the config will not load — 1 refusal.
+  bad-check-options: `justfile.useTheRecipe` bans `npx vitest\b`, which is not one command in words. Name a program and the arguments that make it dangerous, such as "git push --force"; a regex goes under `wholeLine: true`.
+```
+
+**Why:** `justfile.useTheRecipe` passes the keys to `banCommands` as its entries.
+
+### 2.11 · Replace the removed command readers
+
+**Applies if:** `git grep -n -E "tokenizeCommand|gitInvocations|GitInvocation|substitutionInProse\(\[|commitMessage\(ctx\.command|gitDirPrefix\(ctx\.command" -- ':!node_modules'` prints a line.
+
+**Change:**
+
+| 0.2.3 | 0.3.0 |
+| --- | --- |
+| `tokenizeCommand(ctx.command)` | `ctx.commands`: one entry per command, each with `program`, `args`, `text`, `heredocs`, `substitutions`, `redirects` and `nested`, or `null` when the line does not parse. See [ctx.commands](../reference/ctx.md#ctxcommands) |
+| `gitInvocations(ctx.command)`, `GitInvocation` | `gitCommands(ctx)`, `GitCommand`. Each has `globals`, `subcommand` and `args` as before, plus `command`, the parsed command it was read from, and `argsAt`, where `args` starts in `command.args`. A line that does not parse gives `[]`, not `null` |
+| `commitMessage(ctx.command)` | `commitMessage(ctx)` |
+| `gitDirPrefix(ctx.command)` | `gitDirPrefix(ctx)` |
+| `banCommands({ ban: [substitutionInProse(heads)], matchHeredocs: true })` | `substitutionInProse({ heads })`, a stock check, with each head in words (2.9) |
+
+`commitMessage` and `gitDirPrefix` take any object with `command` and, optionally, `commands`, so a ctx passes as it is. `shellCommands(ctx)` returns `ctx.commands`, or parses `ctx.command` when the ctx has no `commands`. `ShellCommand`, `ShellHeredoc`, `ShellSubstitution` and `ShellRedirect` are exported as types.
+
+`programName(c.program)` is new. It returns a program's name without its path: `/usr/bin/git` gives `git`.
+
+**Why:** every reading of a command now goes through the one parse, and the hand-written tokeniser behind these functions is gone.
+
+### 2.12 · Stop reading `description` in a category
+
+**Applies if:** a `defineCategory` classifier in the repo reads `description` from its facts. `git grep -n defineCategory` finds each classifier.
+
+**Change:** read `facts.agentType` instead. `description` is still on `SessionFacts`, so a config that names it compiles, but it is always `undefined`.
+
+**Why:** the description came from a file Claude Code does not write. A subagent's type now comes from the hook message.
+
+## 3 · What now blocks or passes differently
+
+- **A command that only mentions a banned one passes.** `echo 'npx vitest run'`, `gh issue create --body "ran npx vitest run"`, and a heredoc body that names a command are no longer refused. `git push origin main; ls -f` no longer reads as a force push.
+- **A banned command in a nested command is refused.** A command inside `$( … )`, backticks or `<( … )`, in a `bash -c`, `sh -c` or `eval` string, or behind `sudo`, `env` or `timeout`, is matched as a command of its own.
+- **A here-string fed to a shell is matched as commands.** `bash <<< 'rm -rf build'` is refused by a rule that bans `rm -rf`, as `bash <<'EOF'` with the same line already was.
+- **A program run by its path is refused.** A command rule in words compares the program without its path. `/usr/local/bin/work plan tick F7.B1` is refused by `work.ticksAreTheChilds`, and `/usr/local/bin/npx vitest run` by a `justfile` `recipes` key of `"npx vitest"`.
+- **An argument is compared whole.** `work task-list` passes `work.planIsTheParents`, which bans `work task`. `npx vitest-preview` passes a `recipes` key of `"npx vitest"`.
+- **A flag in any order is refused.** The arguments of an entry match in any order and at any position. `work --verbose plan tick F7.B1` is refused by `work.ticksAreTheChilds`. An entry of `"rm -rf"` refuses `rm -fr build` and `rm -r -f build`. If one of these is now refused, the rule's message says what to run instead.
+- **`git.noForcePush` refuses every spelling of a force-push.** `git -C <dir> push --force`, `/usr/bin/git push -f`, `git push -fu` and `git push origin +main` are refused.
+- **`git.noShellSubstitutionInProse` and `work.noShellSubstitutionInProse` read the parse.** They now pass a backtick in a quoted heredoc, such as `gh pr create --body-file - <<'EOF'`, a backslash-escaped backtick inside double quotes, and a backtick in another command on the same line. They now refuse a bare backtick outside quotes and a backtick in an unquoted heredoc. If one is refused, single-quote the argument, escape each backtick as `` \` ``, or feed the text through a quoted heredoc.
+- **`git.conventionalCommitFormat` reads the commit's own message.** For `git commit -F - <<'EOF'`, it reads that command's heredoc, not the first heredoc on the line. For `-m "$(cat <<'EOF' … EOF)"`, it reads the heredoc's body.
+- **`git.noGateSkip` is new in the `git` pack.** It refuses `git commit --no-verify` (and `-n`), `git -c core.hooksPath=… commit`, `git commit-tree`, `git update-ref` and `git hash-object -w`, which commit without the commit gate. If one is refused, commit normally and fix what the gate refuses. A repo whose workflow needs one of them disables the entry in `flow.config.ts`.
+- **Deletes and reads are read from the parse.** An `rm` inside `$( … )`, a `bash -c` string or behind `sudo` is judged as a delete before it runs; an `rm` named in a quoted argument or a heredoc body is not. The files a command reads, for the breadcrumbs they show, are found the same way.
+- **A config that does not load turns flow off, and says so.** In 0.2.3, every write, delete and command was refused until the config was fixed. Now every hook lets the call through and prints the load error with it, and only the commit gate refuses, until the config loads.
+- **A subagent is classified.** Rules scoped to a category that matches on `agentType` now fire in a real subagent. In 0.2.3, no subagent had a category.
+- **A turn-end rule runs when a subagent hands back.** A rule with no `.for(…)` now holds a subagent as it holds the main chat, and a rule with `.for(…)` runs only for an agent that has one of the categories it names. Claude Code's internal agents, which make prompt suggestions and answer `/btw` side questions, run no rule. See [the turn-end moment](../reference/moments.md#the-turn-end-moment).
+- **A turn-end breadcrumb is shown.** In 0.2.3, a breadcrumb bound at `turn-end` loaded and was never shown. Now it is shown as a note when an agent hands back, the first time and again once the context size has grown by `driftTokens`. Each time it shows, the agent takes one more turn to read it before it hands back.
+- **`flow init` leaves other hooks alone, and exits 1 until flow is installed.** When git already runs hooks from another folder, such as husky's `.husky/_` or a hook in `.git/hooks`, `flow init` does not set `core.hooksPath`. It exits 1, and its output ends with `FLOW IS NOT INSTALLED`, until the `pre-commit` hook git runs calls flow. In 0.2.3, it set `core.hooksPath` to `.githooks` and turned those hooks off. A setup script that runs `flow init && …` in such a repo now stops at init. In a husky repo where an older `flow init` set `core.hooksPath`, husky sets it back to `.husky/_` on its next install, and `flow status` then prints a red `hooks-path` line. See [when git already runs other hooks](../reference/cli.md#when-git-already-runs-other-hooks).
+- **`flow.noUninstall` is new in the `flow` pack.** It refuses `flow uninstall`, with or without `--machine`, when an agent runs it, by any runner such as `npx flow uninstall` or `node node_modules/@jawache/flow/dist/flow.mjs uninstall`. If flow should come off a repo, run `flow uninstall` in your own terminal. See [what `flow uninstall` removes](../reference/cli.md#what-flow-uninstall-removes).
+- **A `wholeLine` entry that is not a valid regex refuses to load.** `banCommands` compiles each `wholeLine` pattern when the rule loads, and `flow status` prints `bad-check-options` for one that does not compile, such as `curl(`. In 0.2.3, it threw on the first command the rule judged.
+- **A `pre-commit` hook git cannot run does not count as calling flow.** When git runs its hooks from a folder other than `.githooks`, and the `pre-commit` hook there calls flow but is not executable, `flow init` and `flow status` print `FLOW IS NOT INSTALLED`, and the block says to run `chmod +x` on it. A hook `flow init` wrote is executable already.
+- **A file git puts in place is not judged.** After `git switch`, `git checkout` or `git pull`, a file that matches the commit `HEAD` points to is not judged and not written back, when that commit was in the repo before the call. In 0.2.3, it was judged like an edit.
+
+## 4 · Optional
+
+- **Take flow off a repo with `flow uninstall`.** It deletes the commit gate, unsets `core.hooksPath`, deletes `.flow/`, and removes flow's six hook entries from the repo's `.claude/settings.json`. `flow uninstall --machine` removes them from the machine-wide settings file too. `flow.config.ts` is kept, and `flow init` wires the repo again. [What `flow uninstall` removes](../reference/cli.md#what-flow-uninstall-removes) lists every path.
+- **Read the parse in a check of your own.** `ctx.commands` lists each command the line runs. [ctx.commands](../reference/ctx.md#ctxcommands) has the fields. This check compares each program without its path, with `programName`, so `/usr/bin/gh` counts as `gh`:
+
+  ```ts
+  const noBareGh = defineCheck((_opts: Record<string, never>) => (ctx) => {
+    const bare = (ctx.commands ?? []).find((c) => programName(c.program) === "gh");
+    return bare === undefined ? ctx.ok() : ctx.fail(`\`${bare.text}\` runs gh directly — run it as \`work gh …\``);
+  });
+  ```
+
+- **Bind `substitutionInProse` for a command of your own that records prose,** such as a deploy script that takes a message:
+
+  ```ts
+  .check(substitutionInProse({ heads: ["notes add"] }))
+  .message(SUBSTITUTION_MESSAGE)
+  ```
+
+- **Say where the `secrets` pack's key is kept.** `pack(secrets, { custody: "file" })` for a key in `.env.keys`; the default, `"native"`, is the OS secret store. With `"file"`, the default encrypt command passes `--no-native`.
+
+## 5 · Verify
+
+```sh
+flow status               # green
+flow test                 # every case green
+flow hook commit --all    # exit 0
+```

package/docs/user/migrations/index.md

@@ -0,0 +1,45 @@
+---
+summary: "one page per release"
+---
+
+# Upgrading flow — migration guides
+
+Each page lists what a repo that uses flow must change to upgrade to one version from the version before it. A repo that uses flow has a `flow.config.ts`, a `.githooks/pre-commit` written by `flow init`, and flow's hook registrations in the Claude Code settings file.
+
+## Upgrade across several versions
+
+Apply the pages one at a time, oldest first. For each page:
+
+1. Install that page's version.
+2. Make every change under **Required changes** whose **Applies if** check says yes.
+3. Read **What now blocks or passes differently**.
+4. Run the page's **Verify** steps, and fix what they report before you open the next page.
+
+Find the version a repo has now with `npm ls @jawache/flow`, or `flow --version` for a global install.
+
+From 0.2.2, these pages are in the npm package. After `npm i -D @jawache/flow@<target>`, they are at `node_modules/@jawache/flow/docs/user/migrations/`, and that folder has every guide up to `<target>`. They are also on GitHub, at <https://github.com/jawache/flow/tree/main/docs/user/migrations>.
+
+To give the upgrade to an agent working in that repo, use this instruction, with the two versions filled in:
+
+```text
+Upgrade @jawache/flow in this repo from <current> to <target>. Read the migration guides
+index at node_modules/@jawache/flow/docs/user/migrations/index.md (or
+https://github.com/jawache/flow/tree/main/docs/user/migrations), then apply every guide
+after <current> up to and including <target>, one at a time, oldest first, following the
+steps that index lists. Stop and report if a Verify step fails.
+```
+
+## The guides
+
+| Version | Released | Upgrades from | Changes needed |
+| --- | --- | --- | --- |
+| [0.3.0](./0.3.0.md) | 2026-10-17 | 0.2.3 | Re-run `flow init`. Add the repo-first line to `.githooks/pre-commit`. Give every guardrail a block case. Rewrite each `banCommands` entry, `substitutionInProse` head and `justfile` `recipes` key in words. Replace `tokenizeCommand` and `gitInvocations` |
+| [0.2.3](./0.2.3.md) | 2026-10-07 | 0.2.2 | None. Bind the `git` pack if the repo does not, to refuse a commit that credits Claude |
+| [0.2.2](./0.2.2.md) | 2026-10-07 | 0.2.1 | Edit `.githooks/pre-commit`, and any other command that runs `flow commit` |
+| [0.2.1](./0.2.1.md) | 2026-10-02 | 0.2.0 | None |
+| [0.2.0](./0.2.0.md) | 2026-10-01 | 0.1.2 | Re-run `flow init`. Remove `override(docs.noMarkdownInUserDocs)`. Check `banCommands` rules about heredoc text |
+| [0.1.2](./0.1.2.md) | 2026-09-16 | 0.1.1 | Only for a repo with its own `depcruise` rule whose layers are written as regexes |
+| [0.1.1](./0.1.1.md) | 2026-09-16 | 0.1.0 | None |
+| [0.1.0](./0.1.0.md) | 2026-09-15 | a checkout linked with `npm link` | Install from npm. Rename the `guard` pack to `flow`. Replace removed checks and entries |
+
+The full list of changes in each release is in [CHANGELOG.md](../../../CHANGELOG.md).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jawache/flow",
-  "version": "0.1.2",
+  "version": "0.3.0",
   "description": "Guardrails and breadcrumbs as code — packs you import, a config that typechecks, one adapter per harness.",
   "license": "MIT",
   "repository": {
@@ -32,7 +32,8 @@
     "dist/flow.mjs",
     "dist/index.mjs",
     "dist/packs.mjs",
-    "dist/types/"
+    "dist/types/",
+    "docs/user/migrations/"
   ],
   "engines": {
     "node": ">=24"
@@ -45,7 +46,8 @@
   },
   "dependencies": {
     "@ast-grep/napi": "^0.42.3",
-    "dependency-cruiser": "^18.1.0"
+    "dependency-cruiser": "^18.1.0",
+    "unbash": "5.1.0"
   },
   "devDependencies": {
     "@ast-grep/lang-python": "^0.0.6",