opencode-gbuild 0.6.0 → 0.6.1

package/README.md

@@ -186,11 +186,16 @@ Every skill reads and writes the graph with `cypherlite` and nothing else — th
 direct JSON editing. The plugin ships the queries as `.cypher` files; skills pipe them into the store:
 
 ```bash
-cypherlite .gbuild/<feature>/db -json < plugins/gbuild/cypher/validate.cypher   # format gate: [] = valid
-cypherlite .gbuild/<feature>/db -json < plugins/gbuild/cypher/status.cypher     # frontier/blocked/waves
-cypherlite .gbuild/<feature>/db -json "MATCH (n:GbuildNode) RETURN n.slug, n.status"   # anything else
+cypherlite .gbuild/<feature>/db --mode jsonl < plugins/gbuild/cypher/validate.cypher   # format gate: no output = valid
+cypherlite .gbuild/<feature>/db --mode jsonl < plugins/gbuild/cypher/progress.cypher   # one row per wave: counts + open nodes
+cypherlite .gbuild/<feature>/db --mode jsonl "MATCH (n:GbuildNode {status: 'failed'}) RETURN n.slug"   # anything else
 ```
 
+Reads are deliberately narrow so a run doesn't pay for the whole graph on every step: `run` claims a
+wave (`dispatch.cypher` returns only that wave's nodes, with their inputs resolved) and records it
+(`record.cypher`, one batched call) — two store calls per wave, regardless of graph size. The full
+per-node view (`status.cypher`) is only for the human-facing `/gbuild:status`.
+
 Required properties and their types are engine constraints, so an invalid write never lands; the rest of
 the contract (enums, edge shapes, coverage, acyclicity, the cut test) is `validate.cypher`. CypherLite
 locks a store while a process has it open, so only the main-context skill touches it, one command at a
@@ -198,7 +203,8 @@ time — subagents get their inputs in their prompt and report back. `reference/
 operating rules.
 
 Tests (repo-root `npm test`) run the Cypher layer against the real binary: `cypher.test.ts` drives the
-worked example through a full run and checks every validator rule and write guard.
+worked example through a full run, checks every validator rule and write guard, and holds a token budget
+— a 40-node run must take two store calls per wave and stay under a fixed number of bytes read.
 
 ## Layout
 
@@ -206,8 +212,8 @@ worked example through a full run and checks every validator rule and write guar
 plugins/gbuild/
   agents/gbuild-reviewer.md   # per-node review, ported from hone-ai's reviewer, never self-review
   agents/gbuild-auditor.md    # end-of-branch maintainability audit, ported from hone-ai's auditor
-  reference/                  # graph-format.md (normative model) + cypher.md (how to talk to the store); shapes/failure-policies/cost-model/checklist inform plan
-  cypher/                     # schema, validate, status/node/feature reads, and run's write scripts
+  reference/                  # graph-format.md (normative model), cypher.md (how to talk to the store), queries.md (ad-hoc recipes); shapes/failure-policies/cost-model/checklist inform plan
+  cypher/                     # schema, validate, progress/attention/status/node/feature reads, and run's dispatch/record/set-status
   templates/example.cypher    # a worked 4-node diamond, written the way plan writes a feature
   skills/{plan,run,status,review,pr}/
   index.ts                    # OpenCode plugin entry: registers the skills + /gbuild-* commands, translating paths/names

package/agents/gbuild-auditor.md

@@ -7,7 +7,7 @@ description: Strict end-of-feature maintainability auditor for a gbuild feature
 
 Unusually strict review of implementation quality, maintainability, and abstraction health. Push for **ambitious** restructurings — "code judo" moves that preserve behavior while making the code dramatically simpler, smaller, and more direct. Delete complexity; don't rearrange it.
 
-The caller passes you the resolved feature slug and the feature context it read from the gbuild store: the `destination`, the acceptance bar (each criterion with the nodes covering it), and every node's recorded output values. Use it for scoping context only — you are auditing the branch's code, not re-grading individual nodes (`gbuild-reviewer` already did that per node, against each node's own contract; your job is the thing no per-node pass can see — what the accumulated diff did to the codebase as a whole). Do not open `.gbuild/` or run `cypherlite` — the caller owns the store. Do NOT write any file — output your audit as your final message exclusively.
+The caller passes you the resolved feature slug and the feature context it read from the gbuild store: the `destination` and the acceptance bar (each criterion with the nodes covering it). Use it for scoping context only — you are auditing the branch's code, not re-grading individual nodes (`gbuild-reviewer` already did that per node, against each node's own contract; your job is the thing no per-node pass can see — what the accumulated diff did to the codebase as a whole). Do not open `.gbuild/` or run `cypherlite` — the caller owns the store. Do NOT write any file — output your audit as your final message exclusively.
 
 ## Core Prompt
 

package/cypher/attention.cypher

@@ -0,0 +1,20 @@
+// Only the nodes that need a decision — no rows means nothing does.
+//   failed             escalated or exhausted; `detail` = the last review's failed criteria
+//   in_progress        claimed but not recorded; if no run is active, an interrupted wave left it
+//   blocked-by-failed  pending behind a failed node, so it can never unblock on its own;
+//                      `detail` = the failed nodes it waits on
+//   cypherlite .gbuild/<slug>/db --mode jsonl < cypher/attention.cypher
+CALL {
+  MATCH (n:GbuildNode {status: 'failed'})
+  RETURN n.slug AS slug, 'failed' AS reason,
+         COLLECT { MATCH (n)-[:REVIEWED]->(r:Review) WITH r ORDER BY r.attempt DESC LIMIT 1 UNWIND r.failed_criteria AS c RETURN c } AS detail
+UNION ALL
+  MATCH (n:GbuildNode {status: 'in_progress'})
+  RETURN n.slug AS slug, 'in_progress' AS reason, [] AS detail
+UNION ALL
+  MATCH (n:GbuildNode {status: 'pending'})-[:DEPENDS_ON*]->(f:GbuildNode {status: 'failed'})
+  WITH n, f ORDER BY f.slug
+  RETURN n.slug AS slug, 'blocked-by-failed' AS reason, collect(DISTINCT f.slug) AS detail
+}
+RETURN slug, reason, detail
+ORDER BY reason, slug;

package/cypher/dispatch.cypher

@@ -1,13 +1,31 @@
-// Mark frontier nodes in_progress just before run fans them out. Only nodes
-// that are pending AND whose every DEPENDS_ON target is completed or cancelled
-// are moved; anything else is silently skipped, so compare `dispatched`
-// against what you asked for.
-//   cypherlite .gbuild/<slug>/db -json --param 'slugs=["a","b"]' < cypher/dispatch.cypher
-UNWIND $slugs AS s
-MATCH (n:GbuildNode {slug: s})
-WHERE n.status = 'pending'
-  AND NOT EXISTS { MATCH (n)-[:DEPENDS_ON]->(d:GbuildNode) WHERE NOT d.status IN ['completed', 'cancelled'] }
+// Claim the next wave: move every frontier node (pending, every DEPENDS_ON
+// target completed or cancelled) to in_progress, and return exactly what its
+// implementing agent needs — nothing about the rest of the graph. An input
+// with a `value` was read from an upstream node; one with a null value is
+// external, and its `shape` says where to find it. No rows = nothing is
+// ready (the graph is done or stuck — ask progress.cypher / attention.cypher).
+// For a router, cancel the unselected branches with set-status.cypher first.
+//   cypherlite .gbuild/<slug>/db --mode jsonl < cypher/dispatch.cypher
+MATCH (n:GbuildNode {status: 'pending'})
+WHERE NOT EXISTS { MATCH (n)-[:DEPENDS_ON]->(d:GbuildNode) WHERE NOT d.status IN ['completed', 'cancelled'] }
 SET n.status = 'in_progress'
-RETURN n.slug AS dispatched
-ORDER BY dispatched;
+RETURN n.slug AS slug,
+       n.title AS title,
+       n.type AS type,
+       n.acceptance AS acceptance,
+       n.failure_policy AS failure_policy,
+       n.model_tier AS model_tier,
+       n.verify AS verify,
+       COLLECT {
+         MATCH (n)-[:INPUT]->(i:Field)
+         OPTIONAL MATCH (i)-[:FROM]->(o:Field)
+         WITH i, o ORDER BY i.name
+         RETURN {name: i.name, shape: i.shape, value: o.value}
+       } AS inputs,
+       COLLECT {
+         MATCH (n)-[:OUTPUT]->(f:Field)
+         WITH f ORDER BY f.name
+         RETURN {name: f.name, shape: f.shape}
+       } AS outputs
+ORDER BY slug;
 .checkpoint

package/cypher/feature.cypher

@@ -1,7 +1,8 @@
-// Feature-level context: destination, the acceptance bar with the nodes that
-// cover each criterion, and every node's recorded output values. What review
-// hands the auditor and what pr builds the description from.
-//   cypherlite .gbuild/<slug>/db -json < cypher/feature.cypher
+// Feature-level context: the destination and the acceptance bar, with the
+// nodes that cover each criterion. What review hands the auditor and what pr
+// builds the description from. Per-node output values are not included — get
+// one node's with node.cypher if you actually need it.
+//   cypherlite .gbuild/<slug>/db --mode jsonl < cypher/feature.cypher
 MATCH (f:Feature)
 RETURN f.feature AS feature,
        f.destination AS destination,
@@ -12,10 +13,4 @@ RETURN f.feature AS feature,
          WITH a ORDER BY a.id
          RETURN {id: a.id, text: a.text,
                  covered_by: COLLECT { MATCH (a)<-[:SATISFIES]-(n:GbuildNode) WITH n ORDER BY n.slug RETURN n.slug }}
-       } AS acceptance,
-       COLLECT {
-         MATCH (n:GbuildNode)
-         WITH n ORDER BY n.slug
-         RETURN {slug: n.slug, title: n.title, status: n.status,
-                 outputs: COLLECT { MATCH (n)-[:OUTPUT]->(o:Field) WITH o ORDER BY o.name RETURN {name: o.name, value: o.value} }}
-       } AS nodes;
+       } AS acceptance;

package/cypher/node.cypher

@@ -1,7 +1,9 @@
 // Everything needed to dispatch or review one node, with inputs resolved
 // through FROM edges to the upstream output values. An input with no FROM is
 // external (from the codebase / environment): its `from` and `value` are null.
-//   cypherlite .gbuild/<slug>/db -json --param slug=<node-slug> < cypher/node.cypher
+// Used for reopen and ad-hoc inspection; run gets its definitions from
+// dispatch.cypher instead.
+//   cypherlite .gbuild/<slug>/db --mode jsonl --param 'slug="<node-slug>"' < cypher/node.cypher
 MATCH (n:GbuildNode {slug: $slug})
 RETURN n.slug AS slug,
        n.title AS title,

package/cypher/progress.cypher

@@ -0,0 +1,25 @@
+// One compact row per wave: node counts by state, and `open` — the slugs in
+// that wave not yet completed or cancelled. A wave with `open: []` is done;
+// the graph is done when every row's `open` is empty. `wave` is the longest
+// DEPENDS_ON chain below a node (0 = no dependencies).
+//   cypherlite .gbuild/<slug>/db --mode jsonl < cypher/progress.cypher
+MATCH (n:GbuildNode)
+OPTIONAL MATCH p = (n)-[:DEPENDS_ON*]->()
+WITH n, coalesce(max(length(p)), 0) AS wave
+WITH n, wave,
+     CASE
+       WHEN n.status <> 'pending' THEN n.status
+       WHEN EXISTS { MATCH (n)-[:DEPENDS_ON]->(d:GbuildNode) WHERE NOT d.status IN ['completed', 'cancelled'] } THEN 'blocked'
+       ELSE 'frontier'
+     END AS state
+ORDER BY n.slug
+RETURN wave,
+       count(*) AS total,
+       sum(CASE WHEN state = 'completed' THEN 1 ELSE 0 END) AS completed,
+       sum(CASE WHEN state = 'cancelled' THEN 1 ELSE 0 END) AS cancelled,
+       sum(CASE WHEN state = 'in_progress' THEN 1 ELSE 0 END) AS in_progress,
+       sum(CASE WHEN state = 'failed' THEN 1 ELSE 0 END) AS failed,
+       sum(CASE WHEN state = 'frontier' THEN 1 ELSE 0 END) AS frontier,
+       sum(CASE WHEN state = 'blocked' THEN 1 ELSE 0 END) AS blocked,
+       [s IN collect(CASE WHEN NOT state IN ['completed', 'cancelled'] THEN n.slug END) WHERE s IS NOT NULL] AS open
+ORDER BY wave;

package/cypher/record.cypher

@@ -0,0 +1,38 @@
+// Record a whole wave's review verdicts in one atomic call. Each result adds a
+// Review (attempt = previous reviews + 1). A pass with a value for every
+// OUTPUT field also completes the node: output values stored on its fields,
+// the implementing agent's own times on the node. A pass missing outputs is
+// recorded as a fail listing them, so the review history stays truthful.
+// Only in_progress nodes are recorded: compare the returned slugs with what
+// you sent. Output values must be scalars or lists of scalars — one nested
+// value rejects the whole batch (InvalidPropertyType); JSON-encode it and
+// resend.
+//   cypherlite .gbuild/<slug>/db --mode jsonl --param 'results=[
+//     {"slug": "a", "verdict": "pass", "failed_criteria": [], "outputs": {"value": 7},
+//      "started_at": "<iso>", "completed_at": "<iso>"},
+//     {"slug": "b", "verdict": "fail", "failed_criteria": ["<criterion>"]}
+//   ]' < cypher/record.cypher
+UNWIND $results AS r
+MATCH (n:GbuildNode {slug: r.slug})
+WHERE n.status = 'in_progress' AND r.verdict IN ['pass', 'fail']
+WITH n, r,
+     COUNT { (n)-[:REVIEWED]->(:Review) } + 1 AS attempt,
+     CASE WHEN r.verdict = 'pass'
+          THEN [k IN COLLECT { MATCH (n)-[:OUTPUT]->(f:Field) RETURN f.name } WHERE r.outputs[k] IS NULL]
+          ELSE [] END AS missing
+WITH n, r, attempt, missing, (r.verdict = 'pass' AND size(missing) = 0) AS ok
+CREATE (n)-[:REVIEWED]->(review:Review {
+  attempt: attempt,
+  verdict: CASE WHEN ok THEN 'pass' ELSE 'fail' END,
+  failed_criteria: coalesce(r.failed_criteria, []) + [k IN missing | 'missing output value: ' + k],
+  at: toString(datetime())
+})
+WITH n, r, attempt, missing, ok, review
+OPTIONAL MATCH (n)-[:OUTPUT]->(f:Field) WHERE ok
+SET f.value = r.outputs[f.name]
+WITH DISTINCT n, r, attempt, missing, ok, review
+FOREACH (_ IN CASE WHEN ok THEN [1] ELSE [] END |
+  SET n.status = 'completed', n.started_at = r.started_at, n.completed_at = r.completed_at)
+RETURN n.slug AS slug, attempt, review.verdict AS verdict, ok AS completed, missing AS missing_outputs
+ORDER BY slug;
+.checkpoint

package/cypher/set-status.cypher

@@ -1,11 +1,14 @@
-// Move a node to a non-completed status: `cancelled` (skip policy), `failed`
-// (escalate, or an exhausted retry/repair), or `pending` (reset a node an
-// interrupted run left in_progress). `completed` is rejected here — only
-// complete.cypher may set it, so it can enforce the review and outputs.
-//   cypherlite .gbuild/<slug>/db -json --param slug=<node-slug> --param status=cancelled \
+// Move nodes to a non-completed status in one call: `cancelled` (skip policy,
+// or a router's unselected branches), `failed` (escalate, an exhausted
+// retry/repair, stop), or `pending` (reset nodes an interrupted run left
+// in_progress). `completed` is rejected — only record.cypher may set it, so it
+// can require a passing review and every output value.
+//   cypherlite .gbuild/<slug>/db --mode jsonl --param 'slugs=["a","b"]' --param 'status="cancelled"' \
 //     < cypher/set-status.cypher
-MATCH (n:GbuildNode {slug: $slug})
+UNWIND $slugs AS s
+MATCH (n:GbuildNode {slug: s})
 WHERE $status IN ['pending', 'in_progress', 'failed', 'cancelled']
 SET n.status = $status
-RETURN n.slug AS slug, n.status AS status;
+RETURN n.slug AS slug, n.status AS status
+ORDER BY slug;
 .checkpoint

package/cypher/status.cypher

@@ -4,7 +4,7 @@
 //   otherwise = the stored status (in_progress, completed, failed, cancelled)
 // `wave` is the longest DEPENDS_ON chain below the node (0 = no dependencies),
 // so nodes sharing a wave are safe to run concurrently.
-//   cypherlite .gbuild/<slug>/db -json < cypher/status.cypher
+//   cypherlite .gbuild/<slug>/db --mode jsonl < cypher/status.cypher
 MATCH (n:GbuildNode)
 OPTIONAL MATCH p = (n)-[:DEPENDS_ON*]->()
 WITH n, coalesce(max(length(p)), 0) AS wave

package/cypher/validate.cypher

@@ -1,5 +1,5 @@
 // gbuild format gate. Zero rows = valid; every row is one violation.
-//   cypherlite .gbuild/<slug>/db -json < cypher/validate.cypher
+//   cypherlite .gbuild/<slug>/db --mode jsonl < cypher/validate.cypher
 // Required properties, their types and slug/acceptance-id uniqueness are
 // engine constraints (schema.cypher) — a write that breaks them never lands.
 // This query checks everything the engine can't: enums, label/type agreement,

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "opencode-gbuild",
-  "version": "0.6.0",
+  "version": "0.6.1",
   "description": "OpenCode plugin for gbuild — graph-native task planning and execution with concurrent fan-out, per-node review, and durable checkpoints.",
   "type": "module",
   "license": "MIT",

package/reference/cypher.md

@@ -1,8 +1,8 @@
 # Talking to the gbuild store
 
 Every gbuild skill reads and writes the feature store (`.gbuild/<feature>/db/`, modelled in
-`reference/graph-format.md`) with the `cypherlite` CLI and nothing else. This file is the operating
-manual; follow it exactly.
+`reference/graph-format.md`) with the `cypherlite` CLI and nothing else. This file is the full operating
+manual; the skills that only run plugin scripts carry the short version of these rules inline.
 
 ## Requirement
 
@@ -31,17 +31,18 @@ or writer — fails with `storage locked` (exit 1). So:
 
 ## Invocation
 
-Always pass `-json` when you need the result. `DB` below is `.gbuild/<feature>/db`.
+Always pass `--mode jsonl`: one compact JSON object per row, one row per line, and no output at all when
+there are no rows. `DB` below is `.gbuild/<feature>/db`.
 
 ```
 # a plugin script
-cypherlite DB -json < ${CLAUDE_PLUGIN_ROOT}/cypher/status.cypher
+cypherlite DB --mode jsonl < ${CLAUDE_PLUGIN_ROOT}/cypher/progress.cypher
 
 # a plugin script with parameters
-cypherlite DB -json --param 'slug="b-consume-doubled"' < ${CLAUDE_PLUGIN_ROOT}/cypher/node.cypher
+cypherlite DB --mode jsonl --param 'slug="b-consume-doubled"' < ${CLAUDE_PLUGIN_ROOT}/cypher/node.cypher
 
-# an ad-hoc read
-cypherlite DB -json "MATCH (n:GbuildNode) RETURN n.slug, n.status ORDER BY n.slug LIMIT 100"
+# an ad-hoc read — return only the columns you need, and keep a LIMIT on anything that can grow
+cypherlite DB --mode jsonl "MATCH (n:GbuildNode {status: 'failed'}) RETURN n.slug LIMIT 20"
 
 # a write you author (plan, reopen, fixes) — quoted heredoc delimiter, so the shell expands nothing
 cypherlite DB <<'CYPHER'
@@ -54,10 +55,12 @@ CYPHER
 
 ## Rules
 
+- **Read narrowly.** Prefer the smallest script that answers the question — `progress` for "how far
+  along / is it done", `attention` for "what needs a decision", `dispatch` for "what runs next". The full
+  per-node `status` is for the human-facing `/gbuild:status` report, not for loops.
 - **Parameters are JSON.** Every `--param` value is JSON, single-quoted for the shell: strings in double
-  quotes (`--param 'slug="01-scan-runners"'`), lists and objects as JSON (`--param 'slugs=["a","b"]'`,
-  `--param 'outputs={"value": 7}'`). Bare values that start with a digit — timestamps, `01-…` slugs —
-  are rejected, so always quote.
+  quotes (`--param 'slug="01-scan-runners"'`), lists and objects as JSON (`--param 'slugs=["a","b"]'`).
+  Bare values that start with a digit — timestamps, `01-…` slugs — are rejected, so always quote.
 - **String literals** in Cypher you author: single quotes by default; double quotes when the text
   contains an apostrophe (`"gbuild's"`); backslash-escape (`\'`, `\"`) when it contains both.
 - **Authored writes are atomic and checkpointed.** Wrap them in `.begin` / `.commit` — if any statement
@@ -65,12 +68,10 @@ CYPHER
   git commits) is always current. The plugin write scripts already do both.
 - **Values are scalars or lists of scalars.** CypherLite cannot store a map as a property value;
   JSON-encode anything nested into a string.
-- **Read the result.** The plugin write scripts are guarded: a write that did nothing returns `[]` (or
-  `completed: false` with the reason). Never assume a write landed.
+- **Read the result.** The plugin write scripts are guarded and return what they actually changed.
+  Compare it with what you asked for; never assume a write landed.
 - **Exit code 1 is a failure** — lock, constraint violation (`ConstraintValidationFailed`), syntax. Read
   stderr, fix, retry the whole transaction.
-- A one-shot write without `.checkpoint` still lands (reads replay the WAL), but `graph.json` stays stale
-  until the next checkpoint — so always end writes with it.
 
 ## Creating a store
 
@@ -87,16 +88,20 @@ the schema constraints and pins the JSON codec, so `graph.json` exists from the
 
 ## Script catalog
 
-All in `${CLAUDE_PLUGIN_ROOT}/cypher/`. Reads print one JSON array; writes end with `.checkpoint`.
-
-| script               | params                                   | returns                                                        | used by |
-| -------------------- | ---------------------------------------- | -------------------------------------------------------------- | ------- |
-| `schema.cypher`      | —                                        | nothing (installs constraints)                                  | plan    |
-| `validate.cypher`    | —                                        | one row per violation (`check`, `detail`); `[]` = valid         | every skill |
-| `status.cypher`      | —                                        | one row per node: `slug`, `title`, `type`, `status`, `state` (`frontier`/`blocked`/stored status), `wave`, `waiting_on`, `review_attempts`, `last_verdict`, `last_failed_criteria`, `started_at`, `completed_at` | every skill |
-| `node.cypher`        | `slug`                                   | one node: properties, `inputs` (resolved through `FROM`: `name`, `shape`, `from`, `value`), `outputs`, `depends_on`, `satisfies`, `reviews` | run     |
-| `feature.cypher`     | —                                        | `destination`, `context`, `out_of_scope`, `acceptance` (with `covered_by`), every node's `outputs` | review, pr |
-| `dispatch.cypher`    | `slugs` (list)                           | `dispatched` — only pending nodes whose dependencies are satisfied | run     |
-| `record-review.cypher` | `slug`, `verdict` (`pass`/`fail`), `failed_criteria` (list) | `attempt`, `verdict`                                     | run     |
-| `complete.cypher`    | `slug`, `outputs` (object), `started_at`, `completed_at` | `completed` (bool), `status`, `has_passing_review`, `missing_outputs` | run |
-| `set-status.cypher`  | `slug`, `status` (`pending`/`in_progress`/`failed`/`cancelled`) | `slug`, `status`                                    | run     |
+All in `${CLAUDE_PLUGIN_ROOT}/cypher/`. Writes end with `.checkpoint`.
+
+| script               | params                    | returns                                                        | used by |
+| -------------------- | ------------------------- | -------------------------------------------------------------- | ------- |
+| `schema.cypher`      | —                         | nothing (installs constraints)                                  | plan    |
+| `validate.cypher`    | —                         | one row per violation (`check`, `detail`); no rows = valid      | every skill |
+| `progress.cypher`    | —                         | one row per wave: `total`, counts per state, `open` (slugs not yet completed or cancelled) | every skill |
+| `attention.cypher`   | —                         | only nodes needing a decision: `slug`, `reason` (`failed` / `in_progress` / `blocked-by-failed`), `detail` | run, status |
+| `dispatch.cypher`    | —                         | claims the whole frontier (→ `in_progress`); per claimed node: `slug`, `title`, `type`, `acceptance`, `failure_policy`, `model_tier`, `verify`, `inputs` (`name`, `shape`, `value`), `outputs` (`name`, `shape`) | run |
+| `record.cypher`      | `results` — list of `{slug, verdict, failed_criteria, outputs, started_at, completed_at}` | per recorded node: `attempt`, `verdict`, `completed`, `missing_outputs` | run |
+| `set-status.cypher`  | `slugs` (list), `status` (`pending` / `in_progress` / `failed` / `cancelled`) | `slug`, `status` per changed node | run |
+| `status.cypher`      | —                         | one row per node: `state`, `wave`, `waiting_on`, review summary, timestamps | status (human report) |
+| `node.cypher`        | `slug`                    | one node in full: properties, `inputs` (with `from`), `outputs`, `depends_on`, `satisfies`, `reviews` | plan (reopen), ad hoc |
+| `feature.cypher`     | —                         | `destination`, `context`, `out_of_scope`, `acceptance` (with `covered_by`) | review, pr |
+
+Ready-made ad-hoc queries (lineage, critical path, repair history, …) are in
+`${CLAUDE_PLUGIN_ROOT}/reference/queries.md`.

package/reference/graph-format.md

@@ -104,7 +104,7 @@ map as a property value. JSON-encode anything nested into a string and say so in
 
 ### `Review` — one reviewer verdict
 
-`attempt` (integer, 1-based, assigned by `record-review.cypher`), `verdict` (`pass | fail`),
+`attempt` (integer, 1-based, assigned by `record.cypher`), `verdict` (`pass | fail`),
 `failed_criteria` (list of the acceptance criteria the reviewer failed; empty on a pass), `at` (string).
 Reviews are never updated or deleted — the repair history stays visible to `status`.
 
@@ -155,7 +155,7 @@ In this model the question has a checkable answer, and `validate.cypher` enforce
 `status` is stored on the node; `frontier` and `blocked` are derived by `status.cypher`, never stored.
 
 ```
-pending ──dispatch──▶ in_progress ──complete──▶ completed
+pending ──dispatch──▶ in_progress ──record (pass)──▶ completed
                           │
                           ├──set-status──▶ failed      (escalate, exhausted retry/repair, stop)
                           └──set-status──▶ cancelled   (skip)
@@ -166,8 +166,8 @@ blocked  = pending ∧ some DEPENDS_ON target not completed-or-cancelled
 
 A `cancelled` dependency counts as satisfied — abandoning an optional node must not wedge its
 dependents. A `failed` one does not — dependents stay blocked rather than build on a broken foundation.
-`completed` can only be set by `complete.cypher`, which refuses unless the node is `in_progress`, has a
-passing `Review`, and every `OUTPUT` has a value.
+`completed` can only be set by `record.cypher`, and only for an `in_progress` node whose review passed
+with a value for every `OUTPUT` — a pass missing outputs is recorded as a failed review naming them.
 
 ## Who enforces what
 
@@ -175,42 +175,10 @@ passing `Review`, and every `OUTPUT` has a value.
 | ------------------------- | ------------------------------------------------------------------------ |
 | engine constraints (`cypher/schema.cypher`) | required properties and their types; unique `slug` and `Acceptance.id` — a violating write never lands |
 | `cypher/validate.cypher`  | exactly one `Feature`; enums; type label matches `type`; non-blank acceptance; `verify` target exists; acceptance linked and covered; allowed edge shapes only; acyclic `DEPENDS_ON`; every chore depended on; every node has an output; field ownership and uniqueness; the `FROM` cut test; completed nodes have a passing review and all output values |
-| write scripts (`cypher/*.cypher`) | `dispatch` moves only frontier nodes; `complete` needs a passing review and every output; `set-status` never sets `completed` |
+| write scripts (`cypher/*.cypher`) | `dispatch` claims only frontier nodes; `record` completes a node only on a pass with every output; `set-status` never sets `completed` |
 
 ## Querying
 
-The plan and its progress are one graph, so any question is a Cypher query. Run ad-hoc reads with
-`cypherlite .gbuild/<feature>/db -json "<query>"` (see `reference/cypher.md`); keep a `LIMIT` on anything
-that could grow.
-
-```cypher
--- the whole plan with progress
-MATCH (n:GbuildNode) RETURN n.slug, n.type, n.status, n.title ORDER BY n.slug
-
--- nodes by type
-MATCH (n:Code) RETURN n.slug, n.title
-
--- full transitive dependency chain of a node
-MATCH (n:GbuildNode {slug: 'd-join-and-sum'})-[:DEPENDS_ON*]->(d) RETURN DISTINCT d.slug
-
--- what waits on a node
-MATCH (n:GbuildNode {slug: 'a-produce-shared-value'})<-[:DEPENDS_ON]-(w) RETURN w.slug
-
--- where a node's inputs come from
-MATCH (:GbuildNode {slug: 'd-join-and-sum'})-[:INPUT]->(i)-[:FROM]->(o)<-[:OUTPUT]-(u)
-RETURN i.name, u.slug, o.name, o.value
-
--- everything downstream of a node's output field (data lineage)
-MATCH (:GbuildNode {slug: 'a-produce-shared-value'})-[:OUTPUT]->(o)<-[:FROM]-(i)<-[:INPUT]-(c)
-RETURN o.name, c.slug, i.name
-
--- critical path (longest dependency chain)
-MATCH p = (n:GbuildNode)-[:DEPENDS_ON*]->(m:GbuildNode) RETURN [x IN nodes(p) | x.slug] AS path
-ORDER BY length(p) DESC LIMIT 1
-
--- which nodes cover each feature criterion
-MATCH (a:Acceptance)<-[:SATISFIES]-(n:GbuildNode) RETURN a.id, collect(n.slug)
-
--- nodes that needed a repair pass
-MATCH (n:GbuildNode)-[:REVIEWED]->(r:Review {verdict: 'fail'}) RETURN n.slug, count(r) AS failed_reviews
-```
+The plan and its progress are one graph, so any question is a Cypher query. The plugin scripts cover
+what the skills need (`reference/cypher.md` § Script catalog); ready-made ad-hoc queries are in
+`reference/queries.md`.

package/reference/queries.md

@@ -0,0 +1,37 @@
+# Ad-hoc queries
+
+The plugin scripts (`reference/cypher.md` § Script catalog) cover everything the skills do. These are for
+the questions in between. Run them with `cypherlite .gbuild/<feature>/db --mode jsonl "<query>"`, one at a
+time; return only the columns you need and keep a `LIMIT` on anything that can grow.
+
+```cypher
+-- the whole plan with progress
+MATCH (n:GbuildNode) RETURN n.slug, n.type, n.status, n.title ORDER BY n.slug
+
+-- nodes by type
+MATCH (n:Code) RETURN n.slug, n.title
+
+-- full transitive dependency chain of a node
+MATCH (n:GbuildNode {slug: 'd-join-and-sum'})-[:DEPENDS_ON*]->(d) RETURN DISTINCT d.slug
+
+-- what waits on a node
+MATCH (n:GbuildNode {slug: 'a-produce-shared-value'})<-[:DEPENDS_ON]-(w) RETURN w.slug
+
+-- where a node's inputs come from
+MATCH (:GbuildNode {slug: 'd-join-and-sum'})-[:INPUT]->(i)-[:FROM]->(o)<-[:OUTPUT]-(u)
+RETURN i.name, u.slug, o.name, o.value
+
+-- everything downstream of a node's output field (data lineage)
+MATCH (:GbuildNode {slug: 'a-produce-shared-value'})-[:OUTPUT]->(o)<-[:FROM]-(i)<-[:INPUT]-(c)
+RETURN o.name, c.slug, i.name
+
+-- critical path (longest dependency chain)
+MATCH p = (n:GbuildNode)-[:DEPENDS_ON*]->(m:GbuildNode) RETURN [x IN nodes(p) | x.slug] AS path
+ORDER BY length(p) DESC LIMIT 1
+
+-- which nodes cover each feature criterion
+MATCH (a:Acceptance)<-[:SATISFIES]-(n:GbuildNode) RETURN a.id, collect(n.slug)
+
+-- nodes that needed a repair pass
+MATCH (n:GbuildNode)-[:REVIEWED]->(r:Review {verdict: 'fail'}) RETURN n.slug, count(r) AS failed_reviews
+```

package/skills/plan/SKILL.md

@@ -163,20 +163,21 @@ slug) fails the transaction and writes nothing — fix the script and run it aga
 ### 9. Validate
 
 ```
-cypherlite .gbuild/<slug>/db -json < ${CLAUDE_PLUGIN_ROOT}/cypher/validate.cypher
+cypherlite .gbuild/<slug>/db --mode jsonl < ${CLAUDE_PLUGIN_ROOT}/cypher/validate.cypher
 ```
 
-`[]` means valid. Every row is a violation (`check`, `detail`): fix it with Cypher — a `.begin` …
-`.commit` … `.checkpoint` script of `MATCH … SET/CREATE/DELETE` — and re-run until it prints `[]`. Never
+No output means valid. Every row is a violation (`check`, `detail`): fix it with Cypher — a `.begin` …
+`.commit` … `.checkpoint` script of `MATCH … SET/CREATE/DELETE` — and re-run until it prints nothing. Never
 hand off or commit a graph that fails validation, and never edit `graph.json` directly.
 
 Then confirm run-readiness:
 
 ```
-cypherlite .gbuild/<slug>/db -json < ${CLAUDE_PLUGIN_ROOT}/cypher/status.cypher
+cypherlite .gbuild/<slug>/db --mode jsonl < ${CLAUDE_PLUGIN_ROOT}/cypher/progress.cypher
 ```
 
-The `wave` column is the decomposition; rows with `state: frontier` are what `run` dispatches first.
+One row per wave: each row's `open` slugs are the decomposition, and the `frontier` counts are what
+`run` claims first. Nodes you expected to run together should share a wave.
 
 ### 10. Commit and stop
 
@@ -192,7 +193,8 @@ Report the branch, the waves, and the frontier. Close with `next: /gbuild:run <s
 
 0. Check out the feature's existing branch if you're not on it. Never chart a reopen onto a different
    branch than the one the graph was charted on.
-1. Read the current graph (`status.cypher`, and `node.cypher` for any node the requirement touches).
+1. Read the current graph narrowly: `progress.cypher` for its shape and what's done, and `node.cypher`
+   only for the nodes the requirement touches.
 2. Design the delta: a new `Acceptance` node (next `a-` id) linked from the `Feature`, and whatever new
    GbuildNodes it needs, with their `Field`s. A new node may depend on an already-completed one — wire
    its `INPUT` `FROM` that node's `OUTPUT` like any other; its value is already recorded. Re-run the
@@ -214,7 +216,7 @@ Report the branch, the waves, and the frontier. Close with `next: /gbuild:run <s
    CYPHER
    ```
 
-4. **Re-run `validate.cypher`** until it prints `[]`, then `status.cypher`. Commit
+4. **Re-run `validate.cypher`** until it prints nothing, then `progress.cypher`. Commit
    (`<slug>: reopen graph — <what was added>`), report the new frontier.
 
 If the requirement needs no new nodes (an existing node's contract already covers it), say so and stop

package/skills/pr/SKILL.md

@@ -14,7 +14,7 @@ This skill MUST run in the **main conversation context**. It MUST NOT be invoked
 
 - **slug**: the first token that isn't a flag. If absent, infer it — the current branch commonly ends in the slug (`plan` checks out `<prefix>/<slug>`), otherwise fall back to the store whose `.gbuild/*/db/graph.json` was most recently modified. If neither resolves, leave `<slug>` unresolved (the auto-fix step degrades gracefully — see Step 4).
 
-When `<slug>` resolved, read `${CLAUDE_PLUGIN_ROOT}/reference/cypher.md` and run its version check — every graph read below goes through `cypherlite`, one command at a time.
+When `<slug>` resolved, every graph read below goes through `cypherlite`: run `cypherlite --version` first (missing → stop; gbuild needs it), one command at a time, always `--mode jsonl` (no output = no rows), and on `storage locked` wait and retry up to 3 times. Anything else: `${CLAUDE_PLUGIN_ROOT}/reference/cypher.md`.
 - **max_rounds**: the value of `--max-rounds N` (also accept `--max-rounds=N`). Default `3` when absent.
 
 ## Step 1: Preconditions
@@ -27,7 +27,7 @@ Verify the environment before touching the remote. Stop with a clear, actionable
 4. **Not on base.** Get the current branch (`git branch --show-current`). If it equals `<base>`, stop — there is nothing to open a PR for.
 5. **Clean tree.** Check for uncommitted changes (`git status --porcelain`). `/gbuild:run` commits each node's work as it goes, so the tree should be clean. If there are uncommitted changes, warn the user and ask whether to proceed (they may want to commit first).
 6. **Commits ahead of base.** Confirm the branch has commits the base lacks (`git log <base>..HEAD --oneline`). If empty, stop — nothing to push.
-7. **Graph finished.** When `<slug>` resolved, run `cypherlite .gbuild/<slug>/db -json < ${CLAUDE_PLUGIN_ROOT}/cypher/status.cypher`. If any row has `state: frontier` or `in_progress`, warn that the graph isn't finished and ask whether to open the PR anyway. If any node is `failed`, name it — a PR built on an escalated node is usually premature.
+7. **Graph finished.** When `<slug>` resolved, run `cypherlite .gbuild/<slug>/db --mode jsonl < ${CLAUDE_PLUGIN_ROOT}/cypher/progress.cypher`. If any row's `open` is non-empty, warn that the graph isn't finished (name the open nodes) and ask whether to open the PR anyway. If any row has `failed` > 0, get their names from `attention.cypher` and name them — a PR built on an escalated node is usually premature.
 
 ## Step 2: Determine the remote & push
 
@@ -47,7 +47,7 @@ Gather context from:
 
 - Commit subjects: `git log <base>..HEAD --oneline`.
 - File overview: `git diff <base>...HEAD --stat`.
-- When `<slug>` resolved: `cypherlite .gbuild/<slug>/db -json < ${CLAUDE_PLUGIN_ROOT}/cypher/feature.cypher` — the `destination`, the acceptance bar (with the nodes covering each criterion), and every node's recorded output values.
+- When `<slug>` resolved: `cypherlite .gbuild/<slug>/db --mode jsonl < ${CLAUDE_PLUGIN_ROOT}/cypher/feature.cypher` — the `destination` and the acceptance bar (with the nodes covering each criterion).
 
 Derive a concise, conventional-commit-style title from the feature/branch and the changes (e.g. `feat(auth): add OAuth login`).
 

package/skills/review/SKILL.md

@@ -15,24 +15,34 @@ branch commonly ends in the slug (`plan` checks out `<prefix>/<slug>`), otherwis
 whose `.gbuild/*/db/graph.json` was most recently modified. Do NOT write any file — this skill outputs to
 chat exclusively.
 
-Read `${CLAUDE_PLUGIN_ROOT}/reference/cypher.md` and run its version check. Then, one after the other,
-run `validate.cypher` and `status.cypher` against `.gbuild/<slug>/db`. If the frontier is non-empty or
-nodes are still `in_progress`, say the graph isn't finished and ask whether to audit anyway — auditing a
-half-built branch produces findings that the remaining nodes were going to address.
+Store rules: run `cypherlite --version` first (missing → stop; gbuild needs it). One `cypherlite`
+command at a time, always `--mode jsonl` (no output = no rows); on `storage locked` wait and retry up to
+3 times. Anything else: `${CLAUDE_PLUGIN_ROOT}/reference/cypher.md`.
+
+Check the graph is finished — one row per wave, cheap:
+
+```
+cypherlite .gbuild/<slug>/db --mode jsonl < ${CLAUDE_PLUGIN_ROOT}/cypher/progress.cypher
+```
+
+If any row's `open` is non-empty, say the graph isn't finished (name the open nodes) and ask whether to
+audit anyway — auditing a half-built branch produces findings that the remaining nodes were going to
+address.
 
 ## Run the audit
 
 Fetch the feature context:
 
 ```
-cypherlite .gbuild/<slug>/db -json < ${CLAUDE_PLUGIN_ROOT}/cypher/feature.cypher
+cypherlite .gbuild/<slug>/db --mode jsonl < ${CLAUDE_PLUGIN_ROOT}/cypher/feature.cypher
 ```
 
 Launch the `gbuild-auditor` subagent (agents/gbuild-auditor.md — this plugin's own copy, gbuild does not
 depend on hone-ai being installed). Pass it:
 
-- The resolved slug and the `feature.cypher` result verbatim (destination, acceptance bar with the nodes
-  covering each criterion, every node's recorded outputs) — the auditor never opens the store itself.
+- The resolved slug and the `feature.cypher` result verbatim (destination and the acceptance bar with
+  the nodes covering each criterion) — the auditor never opens the store itself, and reads the code from
+  the branch diff.
 - Tell it to audit the current branch.
 
 The sub-agent runs the full audit in its own fresh context and returns the audit as its final message.

package/skills/run/SKILL.md

@@ -2,37 +2,41 @@
 description: Executes a gbuild graph — dispatches every ready-and-independent node in the current wave concurrently, reviews each node's output with gbuild-reviewer before recording it complete, and resumes only the remaining frontier on re-invocation. Use after /gbuild:plan has charted the graph.
 ---
 
-Run the graph in `.gbuild/$ARGUMENTS/db` (the feature slug is `$ARGUMENTS`).
+Run the graph in `.gbuild/$ARGUMENTS/db` (the feature slug is `$ARGUMENTS`; `DB` below).
 
 **CRITICAL: this skill must run in the main context, not inside a forked agent.** It dispatches its own
 subagents per node; a subagent cannot itself fan out further subagents reliably. It is also the store's
 **only writer**: subagents never run `cypherlite` — they get what they need in their prompt and report
-back in their final message, and this skill records it. Read `${CLAUDE_PLUGIN_ROOT}/reference/cypher.md`
-first and run its version check; `DB` below is `.gbuild/<feature>/db`.
+back in their final message, and this skill records it.
 
-## Step 0: Load and query
+## Store rules
 
-**Confirm the graph is well-formed:**
+- `cypherlite --version` first. If it's missing, stop: gbuild needs it
+  (`curl -sSfL https://neo4j-labs.github.io/cypherlite/install.sh | bash`).
+- One `cypherlite` command at a time against `DB` — never parallel tool calls on it, never from a subagent.
+- Always `--mode jsonl`: one JSON object per row, no output = no rows. Every `--param` value is JSON,
+  single-quoted for the shell (`--param 'slugs=["a","b"]'`).
+- `storage locked` → another process holds the store: wait a few seconds, retry up to 3 times, then stop.
+  Exit code 1 = failure; read stderr. Anything beyond the scripts below: `${CLAUDE_PLUGIN_ROOT}/reference/cypher.md`.
+- Never re-read what you already hold. The claimed wave's definitions stay valid for its retries.
 
-```
-cypherlite DB -json < ${CLAUDE_PLUGIN_ROOT}/cypher/validate.cypher
-```
-
-Anything but `[]` → stop and report the rows; do not run a graph `plan` didn't finish correctly. Then:
+## Step 0: Check and recover
 
 ```
-cypherlite DB -json < ${CLAUDE_PLUGIN_ROOT}/cypher/status.cypher
+cypherlite DB --mode jsonl < ${CLAUDE_PLUGIN_ROOT}/cypher/validate.cypher
+cypherlite DB --mode jsonl < ${CLAUDE_PLUGIN_ROOT}/cypher/attention.cypher
 ```
 
-- **Rows with `state: in_progress`** at this point are left over from an interrupted run (this skill is
-  the only writer, and it records every node before finishing). Check `git log` for commits the node's
-  agent already made, reset each to `pending` with `set-status.cypher` (`--param 'status="pending"'`) so
-  it re-dispatches, and mention it in the report.
-- The rows with `state: frontier` are the set ready right now — not a judgement call; the query already
-  excludes anything blocked, in flight, or done.
-- If there is no frontier and every row is `completed` or `cancelled`, the graph is done — report that
-  and stop. If there is no frontier but nodes remain incomplete, there's a stuck cluster (likely an
-  `escalate`d or `stop`ped node, now `failed`) — report what's blocking and stop.
+- `validate` printing anything → stop and report the rows; do not run a graph `plan` didn't finish
+  correctly.
+- `attention` rows with reason `in_progress` are left over from an interrupted run (this skill is the
+  only writer and records every node before finishing). Check `git log` for commits their agents already
+  made, then reset them all in one call so they re-dispatch, and mention it in the report:
+
+  ```
+  cypherlite DB --mode jsonl --param 'slugs=["<slug>", ...]' --param 'status="pending"' \
+    < ${CLAUDE_PLUGIN_ROOT}/cypher/set-status.cypher
+  ```
 
 ## Step 1: Establish VCS facts
 
@@ -41,100 +45,102 @@ Default to `git`. `git check-ignore -q .gbuild/` tells you whether to commit the
 ## Step 2: Pick a backend
 
 **Workflow tool**, if this session has opted into multi-agent orchestration (ultracode, or the user
-asked for a workflow explicitly) — translate the frontier into a `pipeline()`/`parallel()` script: each
-node is an `agent()` implement call, immediately followed by a `gbuild-reviewer` `agent()` review call
-scoped to that node's outputs + `acceptance`, using `schema` for the pass/fail verdict. Code nodes
+asked for a workflow explicitly) — translate each claimed wave into a `pipeline()`/`parallel()` script:
+each node is an `agent()` implement call, immediately followed by a `gbuild-reviewer` `agent()` review
+call scoped to that node's outputs + `acceptance`, using `schema` for the pass/fail verdict. Code nodes
 touching files that could conflict with a concurrent sibling get `isolation: 'worktree'`.
 Controlled-cycle clusters become a bounded `while` loop per `${CLAUDE_PLUGIN_ROOT}/reference/shapes.md`'s
 round cap. Route `model_tier: strong` nodes via `opts.model` where the harness supports an override. The
-script never touches the store: collect every implement and review result, then record them from the
-main context exactly as step 3.4 describes.
+script never touches the store: collect the results and record them from the main context (step 3.4).
 
 **Fallback** (default — no opt-in required, and always what step 3 below assumes): fire one `Agent`
-tool call per frontier node, **all in a single message** — this is what makes the fan-out real rather
+tool call per claimed node, **all in a single message** — this is what makes the fan-out real rather
 than claimed. Do not dispatch them one at a time across separate messages; that's exactly the serial
 behavior this plugin replaces.
 
-## Step 3: One wave (fallback backend)
+## Step 3: One wave
 
-1. **MARK.** Move the whole frontier to `in_progress` in one call and check that `dispatched` lists every
-   slug you passed:
+1. **CLAIM.**
 
    ```
-   cypherlite DB -json --param 'slugs=["<slug>", ...]' < ${CLAUDE_PLUGIN_ROOT}/cypher/dispatch.cypher
+   cypherlite DB --mode jsonl < ${CLAUDE_PLUGIN_ROOT}/cypher/dispatch.cypher
    ```
 
-   Then fetch each node's definition — `node.cypher` with `--param 'slug="<slug>"'`, one call per node,
-   one after the other. Its `inputs` are already resolved: each input read from another node carries
-   the upstream `value`.
+   It moves the whole frontier to `in_progress` and prints one row per claimed node with everything its
+   agent needs: `slug`, `title`, `type`, `acceptance`, `failure_policy`, `model_tier`, `verify`,
+   `inputs` (an input with a `value` came from an upstream node; one without is external — its `shape`
+   says where to find it), and `outputs`. **No rows** → nothing is ready: go to step 5.
 
-2. **IMPLEMENT.** In one message, spawn one `Agent` per node. Give each the node's `slug`, `title`,
-   `type`, `inputs` (name, shape, value — or for an input with no `from`, where to find it),
-   `outputs` (name, shape), and `acceptance`. Tell it to:
+2. **IMPLEMENT.** In one message, spawn one `Agent` per claimed node with its row. Tell it to:
    - actually do the work — for `code`/`test`/`chore` nodes make the change in the working tree (not
      describe it) and commit it, message `<feature>/<slug>: <what changed>`;
    - produce a value for every output field: a scalar or a list of scalars, JSON-encoding anything
      nested into a string;
    - record its own UTC start and finish (`date -u +%Y-%m-%dT%H:%M:%SZ`) and end its final message with
-     a JSON object `{"started_at": "...", "completed_at": "...", "outputs": {...}}`;
+     `{"started_at": "...", "completed_at": "...", "outputs": {...}}`;
    - **not** run `cypherlite` or touch `.gbuild/`.
 
-3. **REVIEW.** Once IMPLEMENT returns, spawn a `gbuild-reviewer` agent per node, again all in one message
+3. **REVIEW.** Once IMPLEMENT returns, spawn a `gbuild-reviewer` per node, again all in one message
    (`agents/gbuild-reviewer.md` — this plugin's own copy, gbuild does not depend on hone-ai being
-   installed). Give it the node definition from `node.cypher`, the implementing agent's reported
-   outputs, and where the diff is. Never let the implementing agent review its own work.
+   installed). Give it the node's row, the agent's reported outputs, and where the diff is. Never let
+   the implementing agent review its own work.
 
-4. **RECORD** — sequentially, one `cypherlite` call at a time, after the agents returned. For each node:
+4. **RECORD** the whole wave in one call — one result per node, `verdict` from the reviewer's
+   `VERDICT:` line, `failed_criteria` from its `[fail]` lines:
 
    ```
-   cypherlite DB -json --param 'slug="<slug>"' --param 'verdict="pass"' --param 'failed_criteria=[]' \
-     < ${CLAUDE_PLUGIN_ROOT}/cypher/record-review.cypher
+   cypherlite DB --mode jsonl --param 'results=[
+     {"slug": "<slug>", "verdict": "pass", "failed_criteria": [], "outputs": {...},
+      "started_at": "<iso>", "completed_at": "<iso>"},
+     {"slug": "<slug>", "verdict": "fail", "failed_criteria": ["<criterion>"]}
+   ]' < ${CLAUDE_PLUGIN_ROOT}/cypher/record.cypher
    ```
 
-   (`verdict="fail"` and the reviewer's failed criteria as `failed_criteria` on a fail.)
-
-   - **Pass** (`VERDICT: pass`): record it complete with the agent's outputs and times.
-
-     ```
-     cypherlite DB -json --param 'slug="<slug>"' --param 'outputs={...}' \
-       --param 'started_at="<iso>"' --param 'completed_at="<iso>"' < ${CLAUDE_PLUGIN_ROOT}/cypher/complete.cypher
-     ```
-
-     Check `completed: true`. If it is `false`, `missing_outputs` names the output fields the agent didn't
-     produce — treat that as a failed review with those as the failed criteria. An `InvalidPropertyType`
-     error means an output value was a map: JSON-encode it into a string and record again.
-   - **Fail**: apply the node's `failure_policy` (`${CLAUDE_PLUGIN_ROOT}/reference/failure-policies.md`).
-     `retry`/`repair` re-dispatch implement → review (bounded: 2 attempts — `review_attempts` in
-     `status.cypher` counts them) with the reviewer's failed criteria fed back in; the node stays
-     `in_progress`. `fallback` dispatches the named alternate approach. `skip` sets it `cancelled`,
-     `escalate` sets it `failed` (its dependents stay blocked; siblings elsewhere keep going), both with
-     `set-status.cypher`. `stop` sets it `failed` and halts the entire run.
+   Each returned row says whether that node `completed`. A slug missing from the output was not
+   recorded (it wasn't `in_progress`) — find out why before moving on. `InvalidPropertyType` means an
+   output value was a map; the whole batch was rejected — JSON-encode it and send the batch again.
+
+5. **FAILURES.** For each row with `completed: false` (a failed review, or a pass `record` downgraded
+   because `missing_outputs` is non-empty), apply the node's `failure_policy`
+   (`${CLAUDE_PLUGIN_ROOT}/reference/failure-policies.md`), using its `attempt` as the count:
+   - `retry` / `repair` → re-dispatch implement → review with the failed criteria fed back in, reusing
+     the row you already hold, then record just those nodes. Bounded: 2 attempts.
+   - `fallback` → dispatch the named alternate approach the same way.
+   - `skip` → `cancelled`; `escalate` (or an exhausted retry/repair) → `failed`, its dependents stay
+     blocked while siblings elsewhere keep going; `stop` → `failed` and halt the entire run. One
+     `set-status.cypher` call per status, with every slug that gets it.
+   - A completed router (`decision` choosing a branch) → cancel the unselected branches with
+     `set-status.cypher` before the next claim.
 
 Nodes in the same wave never read each other's outputs, so true concurrent dispatch is safe by
-construction — only the recording is serialized.
+construction — only the store calls are serialized.
 
 ## Step 4: Next wave
 
 If `.gbuild/` isn't ignored, commit the store: `git add .gbuild/<feature>/db` and
-`git commit -m "<feature>: record wave <n>"`. Re-run `status.cypher`. If the wave that just finished
-unblocked new frontier nodes, repeat step 3 for them. Keep going until there is no frontier (done, or
-stuck — see step 0's exit conditions).
+`git commit -m "<feature>: record wave <n>"`. Then claim again (step 3). Keep going until a claim
+returns no rows.
 
 ## Step 5: Report and stop
 
-Report: which nodes ran this invocation, which passed review outright vs. needed a repair pass, what's
-newly on the frontier or still blocked, and any `failed` nodes needing a decision.
+```
+cypherlite DB --mode jsonl < ${CLAUDE_PLUGIN_ROOT}/cypher/progress.cypher
+cypherlite DB --mode jsonl < ${CLAUDE_PLUGIN_ROOT}/cypher/attention.cypher
+```
+
+Every `progress` row with `open: []` → the graph is done. Otherwise `attention` names what's stuck
+(`failed` nodes with their last failed criteria, and what they block).
 
-Close with the next step:
+Report: which nodes ran this invocation, which passed review outright vs. needed a repair pass, and any
+`failed` nodes needing a decision. Close with the next step:
 
-- **Graph fully done** (every node `completed` or `cancelled`) → say so plainly, then
-  `next: /gbuild:review <feature>` — the per-node reviews graded each node against its own contract;
-  nothing has yet looked at what the accumulated diff did to the codebase.
-- **Work remains** (frontier non-empty, or nodes `failed` awaiting a decision) →
-  `next: /gbuild:status <feature>`.
+- **Graph fully done** → say so plainly, then `next: /gbuild:review <feature>` — the per-node reviews
+  graded each node against its own contract; nothing has yet looked at what the accumulated diff did to
+  the codebase.
+- **Work remains** (nodes `failed` awaiting a decision) → `next: /gbuild:status <feature>`.
 
 ## Resuming
 
-Re-invoking `/gbuild:run <feature>` after an interruption re-runs step 0 fresh: completed and cancelled
-nodes are excluded from the frontier automatically, and nodes an interrupted wave left `in_progress` are
-reset and re-dispatched. Nothing needs to be told what already finished — the store is the memory.
+Re-invoking `/gbuild:run <feature>` after an interruption re-runs step 0 fresh: nodes an interrupted
+wave left `in_progress` are reset, and the next claim picks up exactly the remaining frontier. Nothing
+needs to be told what already finished — the store is the memory.

package/skills/status/SKILL.md

@@ -2,10 +2,16 @@
 description: Reports a gbuild feature's graph — frontier, blocked, in-flight, completed, each node's review verdict, and the cluster shapes with evidence of what actually ran concurrently. Use to check progress or diagnose a stuck run.
 ---
 
-Report status for `$ARGUMENTS`.
+Report status for `$ARGUMENTS`. This skill only reads the store; `DB` below is `.gbuild/<feature>/db`.
 
-Read `${CLAUDE_PLUGIN_ROOT}/reference/cypher.md` first and run its version check. This skill only reads
-the store; `DB` below is `.gbuild/<feature>/db`.
+## Store rules
+
+- `cypherlite --version` first. If it's missing, stop: gbuild needs it
+  (`curl -sSfL https://neo4j-labs.github.io/cypherlite/install.sh | bash`).
+- One `cypherlite` command at a time — never parallel tool calls on the same store.
+- Always `--mode jsonl`: one JSON object per row, no output = no rows.
+- `storage locked` → another process (likely a running `/gbuild:run`) holds the store: wait a few
+  seconds, retry up to 3 times, then say so. Anything else: `${CLAUDE_PLUGIN_ROOT}/reference/cypher.md`.
 
 ## Mode
 
@@ -16,17 +22,18 @@ the store; `DB` below is `.gbuild/<feature>/db`.
 
 ## Single feature
 
+This is the human-facing report, so it's the one place that reads every node.
+
 ### 1. Load
 
 ```
-cypherlite DB -json < ${CLAUDE_PLUGIN_ROOT}/cypher/status.cypher
-cypherlite DB -json < ${CLAUDE_PLUGIN_ROOT}/cypher/validate.cypher
+cypherlite DB --mode jsonl < ${CLAUDE_PLUGIN_ROOT}/cypher/status.cypher
+cypherlite DB --mode jsonl < ${CLAUDE_PLUGIN_ROOT}/cypher/validate.cypher
 ```
 
 One call after the other. `status.cypher` gives one row per node with its derived `state`
 (`frontier` / `blocked` / `in_progress` / `completed` / `cancelled` / `failed`), `wave`, `waiting_on`,
-review summary and timestamps — don't re-derive any of these by hand. This is a small, bounded read —
-status doesn't scale with graph size the way loading full node prose would.
+review summary and timestamps — don't re-derive any of these by hand.
 
 ### 2. Render the graph
 
@@ -64,11 +71,17 @@ remaining, `in_progress` nodes when no run is active — an interrupted wave `ru
 
 `validate.cypher` is the invariant check — it covers non-empty acceptance, acceptance coverage,
 acyclicity, completed nodes without a passing review or missing an output value, orphan chores, and the
-`FROM` cut test. Report every row it returned, numbered. If it returned `[]`, say so in one line — don't
-let silence be ambiguous between "checked, clear" and "not checked."
+`FROM` cut test. Report every row it returned, numbered. If it returned nothing, say so in one line —
+don't let silence be ambiguous between "checked, clear" and "not checked."
 
 ## All-features mode
 
-For each `.gbuild/<slug>/db` found, run `status.cypher` — one store at a time — and print one line: slug,
-node counts by state, and whether the frontier is empty (done or stuck) or has ready work. Point at
-`/gbuild:status <slug>` for detail.
+Don't read every node of every feature. For each `.gbuild/<slug>/db` found, one store at a time:
+
+```
+cypherlite .gbuild/<slug>/db --mode jsonl < ${CLAUDE_PLUGIN_ROOT}/cypher/progress.cypher
+```
+
+Print one line per feature: slug, node counts by state summed over its waves, and whether it's done
+(every `open` empty), has ready work (`frontier` > 0), or is stuck. Point at `/gbuild:status <slug>` for
+detail.

package/cypher/complete.cypher

@@ -1,23 +0,0 @@
-// Record a node as completed: store its output values on its OUTPUT fields
-// and the implementing agent's own start/finish times. Guarded — it writes
-// nothing unless the node is in_progress, has a passing Review, and $outputs
-// has a value for every declared output. Check `completed` in the result;
-// `missing_outputs` / `has_passing_review` say why when it is false.
-// Output values must be scalars or lists of scalars; JSON-encode anything
-// nested into a string.
-//   cypherlite .gbuild/<slug>/db -json --param slug=<node-slug> \
-//     --param 'outputs={"value": 7}' --param started_at=<iso> --param completed_at=<iso> \
-//     < cypher/complete.cypher
-MATCH (n:GbuildNode {slug: $slug})
-WITH n,
-     [k IN COLLECT { MATCH (n)-[:OUTPUT]->(f:Field) RETURN f.name } WHERE $outputs[k] IS NULL] AS missing,
-     EXISTS { (n)-[:REVIEWED]->(:Review {verdict: 'pass'}) } AS passed
-WITH n, missing, passed, (n.status = 'in_progress' AND passed AND size(missing) = 0) AS ok
-OPTIONAL MATCH (n)-[:OUTPUT]->(f:Field) WHERE ok
-SET f.value = $outputs[f.name]
-WITH DISTINCT n, missing, passed, ok
-FOREACH (_ IN CASE WHEN ok THEN [1] ELSE [] END |
-  SET n.status = 'completed', n.started_at = $started_at, n.completed_at = $completed_at)
-RETURN n.slug AS slug, ok AS completed, n.status AS status,
-       passed AS has_passing_review, missing AS missing_outputs;
-.checkpoint

package/cypher/record-review.cypher

@@ -1,17 +0,0 @@
-// Record one gbuild-reviewer verdict as a Review node. `attempt` is assigned
-// here (previous reviews + 1), so repair history is never lost.
-// failed_criteria is the list of acceptance criteria the reviewer failed
-// (pass `[]` on a pass).
-//   cypherlite .gbuild/<slug>/db -json --param slug=<node-slug> --param verdict=pass \
-//     --param 'failed_criteria=[]' < cypher/record-review.cypher
-MATCH (n:GbuildNode {slug: $slug})
-WHERE $verdict IN ['pass', 'fail']
-WITH n, COUNT { (n)-[:REVIEWED]->(:Review) } + 1 AS attempt
-CREATE (n)-[:REVIEWED]->(r:Review {
-  attempt: attempt,
-  verdict: $verdict,
-  failed_criteria: $failed_criteria,
-  at: toString(datetime())
-})
-RETURN n.slug AS slug, r.attempt AS attempt, r.verdict AS verdict;
-.checkpoint