> ## Documentation Index
> Fetch the complete documentation index at: https://graph-unify-model-roles.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# Changelog

<Update label="Graph v0.13.0" description="September 2, 2026" tags={["Graph"]}>
  #### Configuration file schemas are now versioned

  Config, plan, tool, and store documents each carry their own schema version (starting at v1), separate from the `graph` binary version. This lets file formats evolve on their own schedule going forward, while ensuring your binary remains up to date.

  <Prompt description="Migration suggested" icon="sparkle" iconType="solid" actions={["copy"]}>
    ````markdown theme={null}
    # Migrate graph config, plans, and tools to v0.13.0

    You are upgrading the graph files in this repository — `.graph/config.toml`,
    the plans under `.graph/plans/`, the user tools under `.graph/tools/`, and,
    if the user asks, the global library in `~/.config/graph/` — to graph
    v0.13.0. The release is backward compatible for every well-formed file:
    nothing you leave untouched changes meaning. But two things need checking
    before the upgrade is trusted, and one file kind can now be stamped with a
    version. Be conservative: apply only the migrations below; do not
    restructure unrelated steps, tools, or config.

    ## Prerequisites

    - `graph --version` must report ≥ 0.13.0 wherever these files are read.
    - If plans run in CI from the container image
      (`ghcr.io/tylerdavis/graph:vX.Y.Z`), the pin must move to ≥ v0.13.0
      **in the same PR** as any file you stamp with a `version` key (Migration 3
      below). A pre-0.13 binary reads the key as an unknown field: it refuses a
      stamped `config.toml` outright and skips a stamped plan from its catalog.
      Files load from the repo checkout but the engine comes from the pinned
      image, so the two must move atomically. Check `.github/workflows/` for
      `image:` pins.

    ## What v0.13.0 changes (facts to work from)

    **1. Every file kind now carries a file version, separate from the binary.**
    Config, plan documents, tool documents, and the data directory each have an
    integer version that moves only when that file's schema changes. This
    release introduces all four at **v1**, which is the schema graph has always
    read — the changelog entries `Config v1`, `Plan v1`, `Tool v1`, and
    `Store v1` next to `Graph v0.13.0` record the introduction and carry no
    schema change. Where the version lives, and what a missing one means:

    | File | Version key | Missing means |
    | --- | --- | --- |
    | `config.toml` (global and project) | top-level `version = 1` | version 1 |
    | plan documents | top-level `version: 1` | version 1 |
    | tool documents | top-level `version: 1` | version 1 |
    | data directory | `<data_dir>/FORMAT`, written on first open | version 1 |

    A binary reads every version in its support window and migrates older files
    in memory as they load; the file on disk changes only when you run a
    `migrate` command. New commands:

    ```text
    graph version                     # binary version + the version each file kind is written at
    graph config check                # each config file's version and whether the merged config loads
    graph config migrate [--global]   # rewrite config.toml to the current version, comments preserved
    graph plan migrate <name|path>    # rewrite one plan file to the current plan version
    graph tools migrate <path>        # rewrite one user tool file to the current tool version
    ```

    `graph config check` prints one line per config file:
    `<path>	version 1	current (unstamped)` for a file with no `version` key,
    `current` once stamped, `migrate` when older than the binary writes, and
    `too new` / `too old` outside the window. Files graph itself writes — the
    workbench's save, `plan new`, `plan draft`, `plan show` — now always carry
    `version: 1`.

    **2. Plan steps and tool documents are read strictly.** Before this
    release, an unknown key on a *step* (top-level plan keys were already
    strict) and any unknown key in a *tool* document were silently dropped.
    Now they are load errors that name the key. A plan with one is left out of
    the catalog with that diagnostic; a tool file with one fails the whole tool
    catalog by path, so every command that builds it stops until the file is
    fixed:

    - A step accepts exactly `id`, `tool_name`, `input`, and `reasoning`. The
      check runs at every depth — inside `decide`'s `then`/`else` and
      `map`/`reduce`'s `do` bodies too. Error shape:
      `steps[0]: unknown field \`retries\`` or
      `steps[0].input.then[0].input.do: unknown field \`timeout\``. Keys inside
      a step's `input` are the tool's business and are not checked.
    - A tool document accepts `name`, `description`, `input_schema`,
      `output_schema`, `read_only`, `kind`, `version`, plus the keys of its
      `kind`: `exec` → `command`, `args`, `env`, `cwd`, `timeout_secs`,
      `output`; `prompt` → `prompt`, `system`, `model`, `caller_output_schema`,
      `caller_model`; `reshape` → `shape`, `caller_shape`. Error shape:
      `unknown field(s) \`tmeout_secs\` for a \`exec\` tool`.

    **3. The `[prompts].workbench` override no longer carries the tool rules.**
    The rules describing what each `workbench__*` tool does to the draft are
    now appended after the override and cannot be replaced by it. The override
    is framing and policy only: how the agent should behave in the workbench,
    when it may run or save, whether it reads the project. Previously the
    override was the agent's *only* description of those tools, so `graph config
    init` wrote the full tool list into it and customizations started from
    that text.

    **4. `graph --version` prints two lines** (`graph 0.13.0` then
    `file versions: config 1, plan 1, tool 1, store 1`). `-V` still prints the
    binary version alone; `graph version --json` reports `fileVersions` with
    `oldest` and `current` per kind.

    **5. The data directory gains a `FORMAT` marker** on first open, holding the
    store version. A data directory that was previously read-only at open will
    now fail to open until the marker can be written once.

    ## Migration 1 — REQUIRED: find files the strict reader now rejects

    Run, from the repository root:

    ```text
    graph plan list --json | jq '.skipped'
    graph tools list
    ```

    Every entry under `skipped` whose reason contains `unknown field` is a plan
    that loaded before this release and no longer does. If `graph tools list`
    fails with `<path>: unknown field(s) ...`, fix that file and run it again —
    one bad tool file hides the rest of the catalog. For each hit, open the
    file and decide which of two cases it is:

    - **A misspelling of a real key** (`tool_name` written as `toolname`,
      `timeout_secs` as `timeout`): fix the spelling. The key was being ignored,
      so the file's behavior changes — a timeout that was never applied now
      is. Say so in your report.
    - **A key that was never part of the grammar** (`retries`, `notes`,
      `enabled`, ad-hoc annotations): delete it. If it carried intent worth
      keeping, move it into `reasoning` on a step or `description` on a tool,
      both of which are free text.

    Before:

    ```yaml
    steps:
      - id: E1
        tool_name: user__fetch_issues
        input: { project: "{{input.project}}" }
        retries: 3
        note: flaky on Mondays
    ```

    After:

    ```yaml
    steps:
      - id: E1
        tool_name: user__fetch_issues
        input: { project: "{{input.project}}" }
        reasoning: flaky on Mondays; the tool retries internally
    ```

    Do the same sweep over the global library (`~/.config/graph/plans/`,
    `~/.config/graph/tools/`) if the user asks for it. Also grep for step keys
    the catalog cannot report because the plan is hidden by unconfigured
    `requires_servers`: `graph plan validate <name>` opens those from disk.

    ## Migration 2 — REQUIRED where present: trim the workbench prompt override

    Grep `.graph/config.toml` and `~/.config/graph/config.toml` for a
    `workbench` key under `[prompts]` whose value mentions `workbench__`:

    ```text
    grep -n 'workbench__' .graph/config.toml ~/.config/graph/config.toml
    ```

    If the override contains tool descriptions (`workbench__show_plan reads any
    catalog plan…`, `workbench__load_plan REPLACES the draft…`, and so on), it is
    a copy of the old built-in text. Those rules are now appended after the
    override by graph itself, so the copy is redundant at best and, as the tools
    evolve, a stale contradiction of the real rules at worst.

    - If the override is an unmodified copy of the old default, **delete the
      key** and let the built-in framing apply.
    - If it was customized, **keep only the framing and policy** — the
      sentences about how the agent should behave, when it may run or save,
      whether it reads the project — and drop every line that describes what a
      `workbench__*` tool does.

    Before:

    ```toml
    [prompts]
    workbench = """
    # Plan workbench
    You are running inside the graph plan workbench. Never run or save without asking.
    Operate on that draft with the workbench tools:
    - workbench__show_plan: read any catalog plan's YAML without touching the draft...
    - workbench__load_plan: open a DIFFERENT plan the user explicitly names...
    """
    ```

    After:

    ```toml
    [prompts]
    workbench = """
    Build the draft plan with the user. Never run or save without asking.
    """
    ```

    ## Migration 3 — RECOMMENDED: stamp files with their version

    Stamping is optional — an unstamped file is read as v1 — but it is what
    future upgrades key on, and a stamped file is refused by name, with the
    version it found and the versions the binary reads, instead of failing with
    an unknown-field error when a later schema moves. Only do this once the
    Prerequisites hold everywhere the files are read (in particular, the CI
    image pin).

    ```text
    graph config check
    graph config migrate               # ./.graph/config.toml
    graph config migrate --global      # ~/.config/graph/config.toml, if the user asked for the global library
    graph plan migrate <name>          # once per plan file in .graph/plans/
    graph tools migrate <path>         # once per tool file in .graph/tools/
    ```

    What the rewrites do:

    - `config migrate` writes `version = 1` as the first key and leaves every
      other line, comment, and table where it was. A file already stamped is
      left untouched.
    - `plan migrate` and `tools migrate` rewrite the document through the YAML
      tree, so field order survives. A **leading comment block** (lines before
      the first key) is preserved verbatim; comments elsewhere in the file are
      dropped and the command reports how many. If a plan or tool carries
      comments below its first key that the user wants to keep, either add
      `version: 1` as the first key by hand instead of running `migrate`, or
      move those comments into `reasoning` / `description` first.

    Commit the stamped files together with any image-pin change.

    ## Migration 4 — AWARENESS: scripts that parse `graph --version`

    Grep workflows and scripts for `graph --version`. Anything that expects a
    single line (`graph --version | awk '{print $2}'`, a version-gate in a
    Makefile) should switch to `graph -V` for the bare binary version or
    `graph version --json` for the structured form.

    ## Verify

    1. `graph version` reports `0.13.0` or newer, and
       `file versions: config 1, plan 1, tool 1, store 1`.
    2. `graph config check` exits 0 and shows every config file as `current`
       (or `current (unstamped)` if you skipped Migration 3).
    3. `graph plan list --json | jq '.skipped'` is empty, or contains only
       plans that were deliberately left broken (say which and why).
    4. `graph plan validate <name>` for every plan you touched — must pass.
    5. `graph tools list` builds the catalog without naming any file.
    6. If the workbench override changed, open `graph wb plan` on a scratch plan
       and confirm the agent still edits the draft with the `workbench__*` tools.
    7. Report per file: what was found, what changed, and validation status.
       List the files you inspected and deliberately left alone, with the
       reason.
    ````
  </Prompt>

  ### Added

  * version the config, plan, tool, and store file formats independently of the binary (#121)

  ### Fixed

  * keep the tool rules out of `[prompts].workbench` so an override can't break the agent (#120)
</Update>

<Update label="Config v1" description="September 2, 2026" tags={["Config"]}>
  ### Config.toml now supports schema versioning

  * Introduced with graph v0.13.0.
</Update>

<Update label="Plan v1" description="September 2, 2026" tags={["Plan"]}>
  ### Plan definitions now supports schema versioning

  * Introduced with graph v0.13.0.
</Update>

<Update label="Tool v1" description="September 2, 2026" tags={["Tool"]}>
  ### Tool definitions now supports schema versioning

  * Introduced with graph v0.13.0.
</Update>

<Update label="Store v1" description="September 2, 2026" tags={["Store"]}>
  ### Storage files now supports schema versioning

  * Introduced with graph v0.13.0.
</Update>

<Update label="Graph v0.12.0" description="August 12, 2026" tags={["Graph"]}>
  #### Know what a run costs

  Every run now reports the calls and tokens it spent, and the dollar cost too once you configure `[pricing]` — with no pricing table, you get token counts and no invented figures. The numbers reach you at the seams you already read: `--json` envelopes, an MCP body field, a line on stderr under a TTY, and two JSONL events.

  #### Agent steps that answer even when the budget runs out

  An agent step is now shown its `output_schema` up front and spends its final round producing a conforming result, so exhausting `max_iterations` degrades to a partial answer instead of an empty one. Prompt caching is on by default rather than opt-in per call site.

  #### See what each step promises

  The plan workbench's detail pane shows each step's output contract, so you can check what a step is expected to produce without leaving the TUI.

  #### A missing key says so at first use

  A missing environment variable is now explained when something first needs it, instead of failing silently and leaving you to guess which credential was absent.

  ### Added

  * show each step's output contract in the workbench detail pane
  * token usage and cost tracking, prompt caching, and a turn-key agent step (#115)

  ### Documentation

  * restore themed prose in the v0.11.0 changelog summary
  * add use-graph, the general entry-point skill (#107)

  ### Fixed

  * explain missing env vars at first use instead of dying silently
</Update>

<Update label="Graph v0.11.0" description="August 4, 2026" tags={["Graph"]}>
  #### Keep review comments alive across runs

  The `github` pack adds `gh_pr_review_threads` and `gh_pr_thread_sync`, so a plan can read a pull request's existing review threads and update them in place. A plan that runs on every push can carry its findings forward — resolving what got fixed and leaving what still stands — instead of posting the same comment again.

  ### Added

  * add gh\_pr\_review\_threads and gh\_pr\_thread\_sync to the github pack

  ### Documentation

  * publish a release changelog page, generated in lockstep with releases
  * correct the escaping-mechanism comment in cliff-docs.toml
  * infer a per-release summary and migration prompt via a graph plan
  * keep inferred summaries MDX-safe
  * drop the changelog page description and intro line
  * replace the changelog shell scripts with graph plans
  * place the migration prompt between summary and commit lists
  * restyle changelog summaries as themed prose
  * reference changelog snippets instead of embedding them

  ### Fixed

  * release script keeps the docs release\_version in step
</Update>

<Update label="Graph v0.10.0" description="August 4, 2026" tags={["Graph"]}>
  #### Run plans from anywhere

  graph now serves its plans over MCP, so editors, agents, and other MCP clients can run and author plans without touching the terminal.

  #### Smarter control flow

  Plans can pause to ask a person for input — and declare what happens when nobody is there — and can narrow a list down before working through it, which keeps automations from tripping over items they can't handle.

  #### Sharper diff awareness

  Changed-file listings now say what happened to each file, not just that it changed.

  #### A cleaner scripting surface

  Command output is structured and consistent across the CLI; scripts that scraped the old text output should switch to `--json`.

  <Prompt description="Migration required" icon="sparkle" iconType="solid" actions={["copy"]}>
    ````markdown theme={null}
    # Migrate graph plans to v0.10.0

    You are upgrading the graph plans in this repository — and, if the user asks,
    their global library in `~/.config/graph/plans/` — to graph v0.10.0. The
    release is fully backward compatible: any plan you leave untouched keeps
    working. But one common composition is *latently broken* and must be
    migrated wherever it appears, and two workaround patterns can now be
    simplified. Be conservative: apply only the migrations below; do not
    restructure unrelated steps.

    ## Prerequisites

    - `graph --version` must be ≥ 0.10.0 wherever these plans run.
    - If plans run in CI from the container image
      (`ghcr.io/tylerdavis/graph:vX.Y.Z`), the image pin must move to ≥ v0.10.0
      **in the same PR** as any plan change that uses the new features — plans
      load from the repo checkout, but the engine comes from the pinned image,
      so they must move atomically. Check `.github/workflows/` for pins.

    ## What v0.10.0 adds (facts to work from)

    **1. A `filter` control step** — partitions a list by evaluating a gate once
    per element:

    ```yaml
    - id: E2
      tool_name: filter
      input:
        over: "{{E1.changes}}"          # must render to an array
        where:                          # per-element; {{item}}/{{index}} in scope
          value: "{{item.status}}"
          op: ne                        # eq|ne|gt|lt|gte|lte|empty|not_empty|contains
          to: deleted
    ```

    - Exactly one of `where` (logical, zero LLM calls) or `infer` (a yes/no
      question judged per element — costs one judge call per item; optional
      `concurrency`, and `model` to pin the verdict model).
    - Result: `{items: […], count, dropped: […], dropped_count}` — both halves,
      input order. Empty input or an empty result is a value, not an error.
    - `filter` is the one control step allowed **inside** `decide`/`map`/`reduce`
      bodies. There, its own `{{item}}`/`{{index}}` shadow the enclosing body's
      inside the gate — reference the outer element only in `over`.
    - A gate referencing a field an element lacks fails the step (plans fail
      hard). Filter before iterating rather than expecting per-item failures.

    **2. `builtin__git_changed_files` now returns `changes`** alongside the
    unchanged `files`/`count`: one object per file —
    `{path, status, old_path, additions, deletions, binary}` — where `status` is
    `added|modified|deleted|renamed|copied|type_changed` and `old_path` is set
    for renames/copies. Rename detection is now pinned on (`-M`): a rename is
    always a single `renamed` entry for its new path, no longer varying with the
    machine's `diff.renames` config.

    ## Migration 1 — REQUIRED: reading changed files at a ref

    Find every plan where `git_changed_files` output feeds a `map` over
    `builtin__git_file` (or any tool that reads a path at a ref). Grep for
    plans containing both `git_changed_files` and `git_file`, and for
    `over:` referencing `.files`. This composition crashes on any diff
    containing a deletion (the path no longer exists at `head`).

    Before:

    ```yaml
    - id: E1
      tool_name: builtin__git_changed_files
      input: { base: "{{input.base}}", head: "{{input.head}}", prefix: "" }
    - id: E4
      tool_name: map
      input:
        over: "{{E1.files}}"
        do:
          tool_name: builtin__git_file
          input: { path: "{{item}}", ref: "{{input.head}}" }
    ```

    After (insert a filter; note `{{item}}` becomes `{{item.path}}`):

    ```yaml
    - id: E1
      tool_name: builtin__git_changed_files
      input: { base: "{{input.base}}", head: "{{input.head}}", prefix: "" }
    - id: E1b
      tool_name: filter
      input:
        over: "{{E1.changes}}"
        where: { value: "{{item.status}}", op: ne, to: deleted }
    - id: E4
      tool_name: map
      input:
        over: "{{E1b.items}}"
        do:
          tool_name: builtin__git_file
          input: { path: "{{item.path}}", ref: "{{input.head}}" }
    ```

    **Critical companion fix:** if a later prompt/template enumerates the file
    list and pairs it positionally with the map's results ("numbered to match
    the contents below"), rebuild that numbered list from the SAME array the
    map iterates (`{{#E1b.items}}{{@index}}. {{path}}{{/E1b.items}}`) — never
    from `{{E1.files}}`, which would desynchronize paths from contents. Keep
    deletions visible by adding a separate overview section iterating
    `{{#E1.changes}}` (path, status, `+{{additions}}/-{{deletions}}`) so the
    migration adds context rather than hiding it.

    ## Migration 2 — RECOMMENDED: retire selection workarounds

    - **User exec tools that exist only to filter** a prior step's list (jq/grep
      wrappers, e.g. around `git diff --diff-filter`): replace with a `filter`
      step over the structured field, and delete the tool if nothing else uses
      it.
    - **Whole-list LLM selection** (an `infer` step asked "which of these are
      X?" returning a subset): replace with `filter` + `infer` asking the
      question per item. Mind the cost — one judge call per element — and set
      `concurrency`. Keep whole-list inference only for genuinely cross-item
      questions (ranking, dedup).
    - Do NOT soften tools that fail loudly on missing data as a substitute —
      loud failure on a truly unexpected path is the designed behavior; `filter`
      exists so plans stop asking for paths that cannot exist.

    ## Migration 3 — AWARENESS: rename semantics

    If any plan gates on `count` or pattern-matches `files` in a repo where
    `diff.renames` was disabled, note that renames now surface as one entry
    (new path) instead of a delete+add pair. `old_path` on the `renamed`
    entry carries the origin.

    ## Verify

    1. `graph plan validate <name>` for every plan you touched — must pass.
    2. Where feasible, run the plan against a scratch input in a repo that
       contains a deletion and a rename (use `GRAPH_STORAGE=memory` and a
       temp `.graph/config.toml` to keep real state out of the run).
    3. Report per plan: what pattern was found, what changed, and validation
       status. List plans you inspected and deliberately left alone, with the
       reason.
    ````
  </Prompt>

  ### Added

  * add --json to graph tools list
  * add --json to graph tools show
  * serve graph's plans and authoring commands over MCP
  * stream progress and honor cancellation
  * ask steps — put a question to the user from inside a plan
  * filter steps — partition a list with a per-item gate
  * per-file change objects on git\_changed\_files

  ### Changed

  * return outcomes from the plan commands instead of printing
  * convert the remaining commands and make --json uniform

  ### Documentation

  * add a plan authoring skill for the CLI commands
  * point the authoring loop and quickstart at the plan authoring skill
  * make the authoring skill draft-first
  * frame the skill around the whole plan lifecycle
  * document graph as an MCP server
  * close out the MCP roadmap and point the skill at the server
  * explain why the draft arm cannot use and\_then

  ### Fixed

  * write every plan field in snake\_case, at every depth
  * remove revision-by-redraft from both authoring surfaces
  * don't load a project the user never pointed at
  * honour the documented ask retry budget
  * serve the control steps from the tool catalog
  * keep MCP writes inside the server's own config layer
</Update>

<Update label="Graph v0.9.0" description="July 30, 2026" tags={["Graph"]}>
  #### Ride out provider outages

  Model entries can declare fallbacks, so a failing provider fails over to the next instead of failing your run.

  #### Let a step figure it out

  The new agent step runs a bounded tool-calling loop inside a plan for the parts you cannot script ahead of time — and still returns typed results the rest of the plan can reference.

  #### More places to plug in

  GitHub release and log tools, a Slack pack for posting messages, and full plan management from the command line.

  ### Breaking

  * draft plans one validated step at a time, always — a config carrying `[planner]` now fails to load;

  ### Added

  * model fallbacks for provider outage failover (#67)
  * add the agent control step
  * add gh\_release and git\_log to the github pack
  * add slack pack with slack\_post\_message
  * manage plans from the command line

  ### Changed

  * lift plan authoring rules into graph-core

  ### Documentation

  * rework intro/quickstart, add project-setup skill, tidy release asset names (#65)
  * escape curly braces in template-language frontmatter (#66)
  * reorganize the docs — plans-first IA, one owner per fact
  * coherence pass after the reorg — catalog table parity, models links
  * restructure the workbench page; split the exit-gates opener
  * generate workbench screenshots from executed sessions
  * inline Frame embeds — Mintlify snippets don't interpolate props into JSX attributes
  * place workbench screenshots across the reorganized pages
  * rewrite quickstart manual setup to mirror the fast path
  * replace the introduction's plan-run snippet with a workbench hero shot
  * document the agent control step
  * document the plan authoring commands
  * ship an app manifest and a one-click create-app button

  ### Fixed

  * show never-run steps as skipped after a fired exit gate
  * add fallbacks field to the shots harness ModelChoice
  * close the agent step's validation, path, and boundary gaps
  * carry exit codes back to main instead of exiting in place
  * keep plan list and validate off stdout
  * stop re-rendering caller-supplied reshape shapes
</Update>

<Update label="Graph v0.8.1" description="July 17, 2026" tags={["Graph"]}>
  A plan's root node in the workbench now shows its metadata, inputs, and finish up front, alongside a handful of scrolling and selection fixes.

  ### Added

  * show plan metadata, input schema, and finish on the root node (#61)

  ### Fixed

  * wheel over steps/tool list moves selection (#60)
  * gh\_pr\_ticket default pattern requires a separator (#62)
  * wheel scrolls the steps/tool list view (#63)
  * hide list highlight when selection scrolls out of view (#64)
</Update>

<Update label="Graph v0.8.0" description="July 17, 2026" tags={["Graph"]}>
  #### Steadier plan drafting

  Drafts are built incrementally — an outline, then one validated step at a time — and invalid drafts can be edited or repaired instead of discarded.

  #### Pick the right model per call

  Prompt tools, inference steps, and gates can each name a model, so cheap checks stay cheap and hard calls get the strong model.

  #### Sturdier CI reviews

  The PR-review building blocks grew marker-keyed comments, ticket extraction, and file reading at a ref, and tool resolution is now checked before a plan spends a single step.

  ### Added

  * write the built-in system prompts into the config init starter (#44)
  * steer check plans to explicit exits and list inference to map (#45)
  * named models selectable from prompt tools and builtin\_\_infer (#46)
  * marker-keyed PR comments, ticket extraction, and file/grep at a ref (#47)
  * catalog-aware tool resolution before any step runs (#49)
  * incremental draft strategy — outline, then one validated step per inference (#50)
  * edit input\_schema, requires\_servers, and silent finish via update\_metadata (#51)
  * mouse support — click to focus, switch tabs, select rows, wheel-scroll (#55)
  * add data pack with builtin\_\_reshape for shape projection (#58)
  * optional per-gate model override on exit/decide infer (#59)

  ### Documentation

  * add graph-github-actions-setup skill for coding agents (#42)

  ### Fixed

  * render sub-text and borders with the terminal's dim modifier (#43)
  * PR reviewer no longer emits absence false positives on truncated diffs (#40)
  * paste literally, edit invalid drafts, repair bad drafts, fence agent-only tools (#48)
  * separate outline and drafting phases in workbench trace (#52)
  * show span start time on the left and duration on the right; surface outline call duration (#53)
  * order trace chronologically so draft\_plan brackets its phases; fix outline duration origin (#54)
  * carry failing tool error into aborted run result (#56)
  * default output\_schema type + reset workbench iteration budget on progress (#57)
</Update>

<Update label="Graph v0.7.0" description="July 15, 2026" tags={["Graph"]}>
  #### A workbench for plans

  A dual-pane TUI for drafting and test-running plans: research the project, make precise step-level edits, and watch runs unfold without leaving the terminal.

  #### Simpler storage

  Plan and thread state now lives in plain files — nothing to install or run alongside graph.

  #### Projects carry their setup

  Config discovery is project-first, so a repository can ship its own graph setup, and step ids can be any descriptive identifier.

  ### Breaking

  * replace LadybugDB with file-based storage (#24)

  ### Added

  * plan workbench — dual-pane TUI for drafting and test-running plans (#25)
  * workbench debug logging to \<data\_dir>/workbench.log (#28)
  * workbench step view shows body sub-steps and the finish stage (#30)
  * workbench read\_file/grep/glob tools for researching the project (#29)
  * step ids are any unique identifier, not just E-numbers (#31)
  * workbench tools for precise plan edits: update\_metadata, add\_step, update\_step, delete\_step (#33)
  * \[prompts] config overrides for the chat prompt and workbench addendum (#37)
  * project-first config — config init and default search paths target ./.graph (#38)
  * draft safety, control-step guidance, turn-failure recovery (#36)

  ### Documentation

  * cookbook covers a custom bot identity for the CI reviewer (#23)
  * add @emichy to special thanks (#26)
  * require worktrees for all coding work in CLAUDE.md (#39)

  ### Fixed

  * scrolling reaches wrapped content; PgUp/PgDn is the one scroll binding (#27)
  * draft saves can no longer overwrite a different plan's file (#32)
  * section-scoped bare keys are not roots in plan validation (#34)
  * a broken plan file no longer takes down the whole catalog (#35)
</Update>

<Update label="Graph v0.6.0" description="July 11, 2026" tags={["Graph"]}>
  #### Branch execution with decide steps

  Plans can now include `decide` steps that fork execution into `then` and `else` branches based on a gate, letting you author plans with conditional logic instead of separate plans per outcome. The gate keyword for a `decide` step is `if`.

  #### Iterate over lists with map and reduce

  `map` and `reduce` steps run a body of steps over each item in a list, so repetitive per-item work no longer needs to be unrolled manually in the plan.

  #### Inline PR review comments

  The `pr_review` tool now anchors its findings as inline diff comments on the pull request, rather than only surfacing them elsewhere.

  ### Added

  * decide steps fork plan execution into then/else branches (#15)
  * decide gates read if/then/else — the logical gate keyword is now if (#17)
  * map and reduce steps iterate a body over a list (#18)
  * pr\_review anchors findings as inline diff comments (#20)
</Update>

<Update label="Graph v0.5.0" description="July 10, 2026" tags={["Graph"]}>
  #### Clearer tool listings

  `graph tools list` now groups related tools together and displays them in a tighter, easier-to-scan layout.

  ### Added

  * grouped listing for graph tools list, tighter layout (#14)
</Update>

<Update label="Graph v0.4.1" description="July 10, 2026" tags={["Graph"]}>
  `graph mcp tools` now groups its output by server, and release publishing is atomic — assets can no longer go missing from a published release.

  ### Added

  * group graph mcp tools output by server (#11)

  ### Documentation

  * rewrite README, add MIT license (#12)
</Update>

<Update label="Graph v0.4.0" description="July 10, 2026" tags={["Graph"]}>
  #### Run graph without building it

  Published container images make graph drop-in for CI and containerized environments, and search extensions are vendored into the binary so nothing needs installing alongside it.

  #### Built-ins, organized

  Bundled tools now live under one namespace with a dedicated docs page, and new cookbook sections collect worked examples by solution.

  ### Added

  * publish a container image with each release (#4)
  * vendor lbug fts/vector extensions into the binary (#9)
  * builtin\_\_ namespace for bundled tool packs, Built-ins docs page (#10)

  ### Documentation

  * CI cookbook — the dogfooded plans and workflow, annotated (#7)
  * cookbook as a section — pages by solution category (#8)
</Update>

<Update label="Graph v0.3.0" description="July 10, 2026" tags={["Graph"]}>
  #### Bundled tool packs and CI failure annotations

  `graph` now ships with tool packs included, so plans can call common tools without separate setup. Running plans in GitHub Actions also produces failure annotations, making it easier to spot what went wrong directly in the workflow run.

  ### Added

  * bundled tool packs and GitHub Actions failure annotations (#2)

  ### Fixed

  * portable version bump in release.sh; align workspace version with v0.2.0
</Update>

<Update label="Graph v0.2.0" description="July 10, 2026" tags={["Graph"]}>
  #### End plans early, on purpose

  Plans can now use exit gates to stop execution with an explicit success or error state, instead of running to the end or failing on an unrelated step.

  #### Build plans from other plans

  Plans can now call other plans, so you can compose larger workflows out of smaller, reusable pieces rather than duplicating steps across files.

  ### Added

  * exit gates — end a plan early with success or error state
  * plan composability — plans call plans

  ### Documentation

  * bring CLAUDE.md current — composability, exit gates, storage, build story, conventions
</Update>

<Update label="Graph v0.1.0" description="July 10, 2026" tags={["Graph"]}>
  The first release of graph: author plans — YAML pipelines of tool calls with data flowing between steps — validate them, and run them from the terminal. A built-in agent loop backs `ask` and `chat` for conversational work, tools come from your own definitions or any MCP server, and configuration is layered so a repository can carry its own setup.

  ### Added

  * ladybug spike (validated) + layered config crate
  * clap command tree, tracing, working config show/init/path
  * provider trait, Anthropic + OpenAI-compat providers, structured output with repair, role router
  * rmcp manager — stdio + streamable-http transports, lazy connect, tool discovery with namespacing and overrides, ToolRegistry impl
  * ReAct loop + ask/chat/tools commands
  * thread persistence + observed-shape cache (phase 3)
  * unify thread continuation under --thread
  * strict typed template engine for the \{\{Ex.path}} dialect
  * plan pipeline — planner/validation/execution/solver with bus-driven replanning
  * YAML plan docs, plans-as-tools, plan\_and\_execute (phase 4 complete)
  * JSON input documents for plan run and tools test
  * nested tool display, pipeline progress, streamed solver
  * optional solver — plans can render structured output or run silently
  * backend abstraction — dyn Store everywhere, memory backend
  * user-defined tools — exec, cypher, and prompt kinds
  * schema defaults for plan/tool inputs; fmt fixes
  * codify release process — semver bump, git-cliff changelog, tag-driven binaries
  * run traces — tools\_used in ask envelope, GRAPH\_EVENTS=jsonl event stream

  ### Documentation

  * Mintlify documentation site (25 pages) + CLAUDE.md
  * point repository URLs at the real remote
  * fix clone directory in installation
  * touch content to trigger first build
  * remove build-trigger scratch line
  * plans-first framing of core concepts
  * quickstart — freeze-into-a-plan step
  * plan-first nav order and README framing; drop unverified heading anchors

  ### Fixed

  * shut down servers before runtime teardown; silence child stderr
  * read the shape cache at each planning attempt
  * steps\_executed excludes the input root
  * replace RUSTFLAGS with per-target build.rs link directives
</Update>