opencode-gbuild 0.7.1 → 0.9.0

package/cypher/brief.cypher

@@ -0,0 +1,39 @@
+// One node's brief: everything its implementer or reviewer needs, read by the
+// agent itself (never by the orchestrator). An input with a FROM edge carries
+// the upstream output value and `from` = '<upstream-slug>.output.<name>'; an
+// external input has a null `from` and `value`, and its `shape` says where to
+// look. `failed_criteria` is the latest Review's when it failed (a retry), else
+// []. `notes` holds every note written by a transitive upstream node plus setup
+// and testing notes from any node, upstream first, then newest, at most 20.
+//   cypherlite query --read-only --database <git-common-dir>/gbuild/<slug>/db --mode jsonl --param 'slug="<node-slug>"' < cypher/brief.cypher
+MATCH (n:GbuildNode {slug: $slug})
+RETURN n.slug AS slug,
+       n.title AS title,
+       n.type AS type,
+       n.acceptance AS acceptance,
+       n.verify AS verify,
+       COLLECT {
+         MATCH (n)-[:INPUT]->(i:Field)
+         OPTIONAL MATCH (i)-[:FROM]->(o:Field)<-[:OUTPUT]-(u:GbuildNode)
+         WITH i, o, u ORDER BY i.name
+         RETURN {name: i.name, shape: i.shape, from: u.slug + '.output.' + o.name, 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,
+       COLLECT {
+         MATCH (n)-[:REVIEWED]->(r:Review)
+         WITH r ORDER BY r.attempt DESC LIMIT 1
+         WITH r WHERE r.verdict = 'fail'
+         UNWIND r.failed_criteria AS c
+         RETURN c
+       } AS failed_criteria,
+       COLLECT {
+         MATCH (w:GbuildNode)-[:WROTE]->(nt:Note)
+         WITH nt, CASE WHEN EXISTS { MATCH (n)-[:DEPENDS_ON*]->(w) } THEN 0 ELSE 1 END AS rank
+         WHERE rank = 0 OR nt.topic IN ['setup', 'testing']
+         WITH nt, rank ORDER BY rank, nt.at DESC, nt.text LIMIT 20
+         RETURN {topic: nt.topic, text: nt.text, by: nt.by_node}
+       } AS notes;

package/cypher/check-result.cypher

@@ -0,0 +1,19 @@
+// An implementer's self-check of its result file before it replies (and the
+// reviewer's mechanical output check). Clean when missing_outputs,
+// invalid_outputs and unknown_outputs are [] and has_times is true:
+//   missing_outputs  declared outputs with no value (record would downgrade the pass)
+//   invalid_outputs  values that are not a scalar or a single-type list of
+//                    scalars (record would fail with InvalidPropertyType)
+//   unknown_outputs  keys that are not declared outputs (likely typos; record ignores them)
+//   has_times        started_at and completed_at are strings
+// The missing-output expression is text-identical to record.cypher's
+// (test-pinned).
+//   cypherlite query --read-only --database <git-common-dir>/gbuild/<slug>/db --mode jsonl --param 'slug="<node-slug>"' \
+//     --fetch-params result=<git-common-dir>/gbuild/<slug>/inbox/<node-slug>.json < cypher/check-result.cypher
+MATCH (n:GbuildNode {slug: $slug})
+WITH n, $result AS res, coalesce($result.outputs, {}) AS outputs
+RETURN n.slug AS slug,
+       [k IN COLLECT { MATCH (n)-[:OUTPUT]->(f:Field) WITH f ORDER BY f.name RETURN f.name } WHERE res.outputs[k] IS NULL] AS missing_outputs,
+       [k IN keys(outputs) WHERE outputs[k] IS NOT NULL AND NOT (outputs[k] IS :: STRING | INTEGER | FLOAT | BOOLEAN | LIST<STRING> | LIST<INTEGER> | LIST<FLOAT> | LIST<BOOLEAN>)] AS invalid_outputs,
+       [k IN keys(outputs) WHERE NOT k IN COLLECT { MATCH (n)-[:OUTPUT]->(f:Field) RETURN f.name }] AS unknown_outputs,
+       $result.started_at IS :: STRING NOT NULL AND $result.completed_at IS :: STRING NOT NULL AS has_times;

package/cypher/dispatch.cypher

@@ -1,31 +1,13 @@
-// 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 query --database .gbuild/<slug>/db --mode jsonl < cypher/dispatch.cypher
+// Claim every frontier node (pending, every DEPENDS_ON target completed or
+// cancelled): move it to in_progress and return only what the orchestrator
+// routes on. Each agent reads its own definition with brief.cypher, so no
+// title, acceptance, inputs or outputs pass through the orchestrator. Run it
+// at the start of a run and again after every record.cypher / set-status.cypher
+// call. No rows = nothing newly ready (ask progress.cypher / attention.cypher
+// whether the graph is done or stuck).
+//   cypherlite query --database <git-common-dir>/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 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
+RETURN n.slug AS slug, n.type AS type, n.model_tier AS model_tier, n.failure_policy AS failure_policy
 ORDER BY slug;
-.checkpoint

package/cypher/feature.cypher

@@ -2,7 +2,7 @@
 // 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 query --database .gbuild/<slug>/db --mode jsonl < cypher/feature.cypher
+//   cypherlite query --read-only --database <git-common-dir>/gbuild/<slug>/db --mode jsonl < cypher/feature.cypher
 MATCH (f:Feature)
 RETURN f.feature AS feature,
        f.destination AS destination,

package/cypher/node.cypher

@@ -1,9 +1,10 @@
 // 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.
-// Used for reopen and ad-hoc inspection; run gets its definitions from
-// dispatch.cypher instead.
-//   cypherlite query --database .gbuild/<slug>/db --mode jsonl --param 'slug="<node-slug>"' < cypher/node.cypher
+// Each review carries the reviewer's checklist ([] when it wrote none). Used
+// for status, reopen and ad-hoc inspection; run's agents read their own
+// definition with brief.cypher instead.
+//   cypherlite query --read-only --database <git-common-dir>/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,
@@ -37,5 +38,5 @@ RETURN n.slug AS slug,
        COLLECT {
          MATCH (n)-[:REVIEWED]->(r:Review)
          WITH r ORDER BY r.attempt
-         RETURN {attempt: r.attempt, verdict: r.verdict, failed_criteria: r.failed_criteria, at: r.at}
+         RETURN {attempt: r.attempt, verdict: r.verdict, failed_criteria: r.failed_criteria, checklist: r.checklist, at: r.at}
        } AS reviews;

package/cypher/progress.cypher

@@ -2,7 +2,7 @@
 // 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 query --database .gbuild/<slug>/db --mode jsonl < cypher/progress.cypher
+//   cypherlite query --read-only --database <git-common-dir>/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

package/cypher/record.cypher

@@ -1,38 +1,90 @@
-// 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 query --database .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,
+// Record one node attempt per call. Every call adds a Review (attempt =
+// previous reviews + 1) holding the verdict, its failed criteria and the
+// reviewer's checklist. 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, and its notes and symbols stored as
+// (n)-[:WROTE]->(:Note) and (n)-[:DEFINES]->(:Symbol). A pass missing outputs
+// is recorded as a fail listing them, so the review history stays truthful. A
+// fail stores the Review only: no outputs, notes or symbols.
+// Three params, always all bound (the script can't tell --param from
+// --fetch-params):
+//   verdict  {"slug", "verdict": "pass"|"fail", "failed_criteria": [...]} — the
+//            only source of slug, verdict and failed criteria
+//   result   <inbox>/<node-slug>.json (outputs, started_at, completed_at, and
+//            optional notes and symbols) on a pass whose file exists, else {};
+//            any slug/verdict key in it is ignored
+//   review   <inbox>/<node-slug>.review.json ({checklist}) when it exists, else
+//            {}; string entries only, the first 40, each cut to 300 chars
+// Notes keep only maps with a topic of setup|testing|conventions|gotcha and
+// non-blank string text (trimmed, cut to 300 chars): the first 5 distinct ones,
+// skipping any whose exact (topic, text) is already stored. Symbols keep only
+// maps with string name, file and purpose and a non-blank name and file
+// (trimmed, purpose cut to 160 chars): the first 10 distinct (name, file),
+// skipping any whose (name, file) is already stored. The missing-output
+// expression is text-identical to check-result.cypher's (test-pinned).
+// No row unless the node is in_progress: compare the returned slug with the
+// one sent. Output values must be scalars or lists of scalars — a nested value
+// fails the whole call with InvalidPropertyType and writes nothing.
+// `unselected`: for a completed decision node, the pending dependents reading
+// one of its outputs whose string / list-of-strings value names some readers
+// but not them — cancel them with set-status.cypher before the next dispatch.
+//   cypherlite query --database <git-common-dir>/gbuild/<slug>/db --mode jsonl \
+//     --param 'verdict={"slug":"<node-slug>","verdict":"pass","failed_criteria":[]}' \
+//     --fetch-params result=<git-common-dir>/gbuild/<slug>/inbox/<node-slug>.json \
+//     --fetch-params review=<git-common-dir>/gbuild/<slug>/inbox/<node-slug>.review.json < cypher/record.cypher
+//   cypherlite query --database <git-common-dir>/gbuild/<slug>/db --mode jsonl \
+//     --param 'verdict={"slug":"<node-slug>","verdict":"fail","failed_criteria":["implementer failed: <reason>"]}' \
+//     --param 'result={}' --param 'review={}' < cypher/record.cypher
+WITH $verdict AS v, $result AS res, $review AS rev
+MATCH (n:GbuildNode {slug: v.slug})
+WHERE n.status = 'in_progress' AND v.verdict IN ['pass', 'fail']
+WITH n, v, res, rev,
      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]
+     CASE WHEN v.verdict = 'pass'
+          THEN [k IN COLLECT { MATCH (n)-[:OUTPUT]->(f:Field) WITH f ORDER BY f.name RETURN f.name } WHERE res.outputs[k] IS NULL]
           ELSE [] END AS missing
-WITH n, r, attempt, missing, (r.verdict = 'pass' AND size(missing) = 0) AS ok
+WITH n, v, res, rev, attempt, missing, (v.verdict = 'pass' AND size(missing) = 0) AS ok
+WITH n, v, res, attempt, missing, ok,
+     [c IN coalesce(rev.checklist, []) WHERE (c IS :: STRING) | left(c, 300)][0..40] AS checklist,
+     CASE WHEN ok AND res.notes IS :: LIST<ANY> NOT NULL THEN reduce(acc = [], x IN [x IN res.notes WHERE CASE
+         WHEN NOT x IS :: MAP NOT NULL THEN false
+         WHEN NOT x.text IS :: STRING NOT NULL THEN false
+         WHEN NOT coalesce(x.topic, '') IN ['setup', 'testing', 'conventions', 'gotcha'] THEN false
+         ELSE trim(x.text) <> '' END
+       | {topic: x.topic, text: left(trim(x.text), 300)}] | CASE WHEN x IN acc THEN acc ELSE acc + [x] END)[0..5] ELSE [] END AS notes,
+     CASE WHEN ok AND res.symbols IS :: LIST<ANY> NOT NULL THEN reduce(acc = [], x IN [x IN res.symbols WHERE CASE
+         WHEN NOT x IS :: MAP NOT NULL THEN false
+         WHEN NOT (x.name IS :: STRING NOT NULL AND x.file IS :: STRING NOT NULL AND x.purpose IS :: STRING NOT NULL) THEN false
+         ELSE trim(x.name) <> '' AND trim(x.file) <> '' END
+       | {name: trim(x.name), file: trim(x.file), purpose: left(trim(x.purpose), 160)}]
+       | CASE WHEN any(y IN acc WHERE y.name = x.name AND y.file = x.file) THEN acc ELSE acc + [x] END)[0..10] ELSE [] END AS symbols
 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],
+  failed_criteria: coalesce(v.failed_criteria, []) + [k IN missing | 'missing output value: ' + k],
+  checklist: checklist,
   at: toString(datetime())
 })
-WITH n, r, attempt, missing, ok, review
+WITH n, res, attempt, missing, ok, review, notes, symbols
 OPTIONAL MATCH (n)-[:OUTPUT]->(f:Field) WHERE ok
-SET f.value = r.outputs[f.name]
-WITH DISTINCT n, r, attempt, missing, ok, review
+SET f.value = res.outputs[f.name]
+WITH DISTINCT n, res, attempt, missing, ok, review, notes, symbols
 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
+  SET n.status = 'completed', n.started_at = res.started_at, n.completed_at = res.completed_at)
+WITH n, attempt, missing, ok, review,
+     [x IN notes WHERE NOT EXISTS { MATCH (o:Note) WHERE o.topic = x.topic AND o.text = x.text }] AS notes,
+     [x IN symbols WHERE NOT EXISTS { MATCH (o:Symbol) WHERE o.name = x.name AND o.file = x.file }] AS symbols
+FOREACH (x IN notes |
+  CREATE (n)-[:WROTE]->(:Note {topic: x.topic, text: x.text, by_node: n.slug, at: review.at}))
+FOREACH (x IN symbols |
+  CREATE (n)-[:DEFINES]->(:Symbol {name: x.name, file: x.file, purpose: x.purpose, by_node: n.slug, at: review.at}))
+RETURN n.slug AS slug, attempt, review.verdict AS verdict, ok AS completed, missing AS missing_outputs,
+       size(notes) AS notes_added, size(symbols) AS symbols_added,
+       CASE WHEN ok AND n.type = 'decision' THEN COLLECT {
+         MATCH (n)-[:OUTPUT]->(f:Field)
+         WITH f, COLLECT { MATCH (f)<-[:FROM]-(:Field)<-[:INPUT]-(d:GbuildNode {status: 'pending'}) RETURN d.slug } AS readers,
+              CASE WHEN f.value IS :: STRING THEN [f.value] WHEN f.value IS :: LIST<STRING> THEN f.value ELSE [] END AS named
+         WHERE any(r IN readers WHERE r IN named)
+         UNWIND [r IN readers WHERE NOT r IN named] AS u
+         RETURN DISTINCT u ORDER BY u
+       } ELSE [] END AS unselected;

package/cypher/schema.cypher

@@ -1,5 +1,5 @@
 // gbuild store schema. Run once, when plan creates the store:
-//   cypherlite query --database .gbuild/<slug>/db --snapshot-format json < cypher/schema.cypher
+//   cypherlite query --database <git-common-dir>/gbuild/<slug>/db --snapshot-format json < cypher/schema.cypher
 // Everything the engine can enforce at write time lives here; the rest of the
 // contract is checked by validate.cypher.
 CREATE CONSTRAINT feature_name FOR (n:Feature) REQUIRE n.feature IS :: STRING;
@@ -42,4 +42,22 @@ CREATE CONSTRAINT review_verdict_exists FOR (n:Review) REQUIRE n.verdict IS NOT
 CREATE CONSTRAINT review_at FOR (n:Review) REQUIRE n.at IS :: STRING;
 CREATE CONSTRAINT review_at_exists FOR (n:Review) REQUIRE n.at IS NOT NULL;
 CREATE CONSTRAINT review_failed_criteria FOR (n:Review) REQUIRE n.failed_criteria IS :: LIST<STRING NOT NULL>;
-.checkpoint
+CREATE CONSTRAINT review_checklist FOR (n:Review) REQUIRE n.checklist IS :: LIST<STRING NOT NULL>;
+CREATE CONSTRAINT note_topic FOR (n:Note) REQUIRE n.topic IS :: STRING;
+CREATE CONSTRAINT note_topic_exists FOR (n:Note) REQUIRE n.topic IS NOT NULL;
+CREATE CONSTRAINT note_text FOR (n:Note) REQUIRE n.text IS :: STRING;
+CREATE CONSTRAINT note_text_exists FOR (n:Note) REQUIRE n.text IS NOT NULL;
+CREATE CONSTRAINT note_by_node FOR (n:Note) REQUIRE n.by_node IS :: STRING;
+CREATE CONSTRAINT note_by_node_exists FOR (n:Note) REQUIRE n.by_node IS NOT NULL;
+CREATE CONSTRAINT note_at FOR (n:Note) REQUIRE n.at IS :: STRING;
+CREATE CONSTRAINT note_at_exists FOR (n:Note) REQUIRE n.at IS NOT NULL;
+CREATE CONSTRAINT symbol_name FOR (n:Symbol) REQUIRE n.name IS :: STRING;
+CREATE CONSTRAINT symbol_name_exists FOR (n:Symbol) REQUIRE n.name IS NOT NULL;
+CREATE CONSTRAINT symbol_file FOR (n:Symbol) REQUIRE n.file IS :: STRING;
+CREATE CONSTRAINT symbol_file_exists FOR (n:Symbol) REQUIRE n.file IS NOT NULL;
+CREATE CONSTRAINT symbol_purpose FOR (n:Symbol) REQUIRE n.purpose IS :: STRING;
+CREATE CONSTRAINT symbol_purpose_exists FOR (n:Symbol) REQUIRE n.purpose IS NOT NULL;
+CREATE CONSTRAINT symbol_by_node FOR (n:Symbol) REQUIRE n.by_node IS :: STRING;
+CREATE CONSTRAINT symbol_by_node_exists FOR (n:Symbol) REQUIRE n.by_node IS NOT NULL;
+CREATE CONSTRAINT symbol_at FOR (n:Symbol) REQUIRE n.at IS :: STRING;
+CREATE CONSTRAINT symbol_at_exists FOR (n:Symbol) REQUIRE n.at IS NOT NULL;

package/cypher/set-status.cypher

@@ -3,7 +3,7 @@
 // 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 query --database .gbuild/<slug>/db --mode jsonl --param 'slugs=["a","b"]' --param 'status="cancelled"' \
+//   cypherlite query --database <git-common-dir>/gbuild/<slug>/db --mode jsonl --param 'slugs=["a","b"]' --param 'status="cancelled"' \
 //     < cypher/set-status.cypher
 UNWIND $slugs AS s
 MATCH (n:GbuildNode {slug: s})
@@ -11,4 +11,3 @@ WHERE $status IN ['pending', 'in_progress', 'failed', 'cancelled']
 SET n.status = $status
 RETURN n.slug AS slug, n.status AS status
 ORDER BY slug;
-.checkpoint

package/cypher/status.cypher

@@ -4,16 +4,20 @@
 //   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 query --database .gbuild/<slug>/db --mode jsonl < cypher/status.cypher
+// `last_dependency_at` is the latest completed_at among the node's completed
+// DEPENDS_ON targets (null without any): its gap to `started_at` is how long
+// the node waited for dispatch once its last dependency landed.
+//   cypherlite query --read-only --database <git-common-dir>/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
 OPTIONAL MATCH (n)-[:DEPENDS_ON]->(d:GbuildNode)
 WITH n, wave, d ORDER BY d.slug
-WITH n, wave, [x IN collect(d) WHERE NOT x.status IN ['completed', 'cancelled'] | x.slug] AS waiting_on
+WITH n, wave, [x IN collect(d) WHERE NOT x.status IN ['completed', 'cancelled'] | x.slug] AS waiting_on,
+     max(CASE WHEN d.status = 'completed' THEN d.completed_at END) AS last_dependency_at
 OPTIONAL MATCH (n)-[:REVIEWED]->(r:Review)
-WITH n, wave, waiting_on, r ORDER BY r.attempt DESC
-WITH n, wave, waiting_on, collect(r) AS reviews
+WITH n, wave, waiting_on, last_dependency_at, r ORDER BY r.attempt DESC
+WITH n, wave, waiting_on, last_dependency_at, collect(r) AS reviews
 RETURN n.slug AS slug,
        n.title AS title,
        n.type AS type,
@@ -29,5 +33,6 @@ RETURN n.slug AS slug,
        reviews[0].verdict AS last_verdict,
        reviews[0].failed_criteria AS last_failed_criteria,
        n.started_at AS started_at,
-       n.completed_at AS completed_at
+       n.completed_at AS completed_at,
+       last_dependency_at
 ORDER BY wave, slug;

package/cypher/symbols.cypher

@@ -0,0 +1,9 @@
+// Helpers, types and utilities completed nodes added, for reuse: the reviewer
+// reads it before grepping for duplication, the implementer before writing a
+// new helper. Only completed (merged) nodes' symbols exist, so nodes running at
+// the same time can't see each other's unmerged helpers. At most 100 rows.
+//   cypherlite query --read-only --database <git-common-dir>/gbuild/<slug>/db --mode jsonl < cypher/symbols.cypher
+MATCH (:GbuildNode)-[:DEFINES]->(s:Symbol)
+RETURN s.name AS name, s.file AS file, s.purpose AS purpose, s.by_node AS by
+ORDER BY file, name
+LIMIT 100;

package/cypher/validate.cypher

@@ -1,18 +1,19 @@
 // gbuild format gate. Zero rows = valid; every row is one violation.
-//   cypherlite query --database .gbuild/<slug>/db --mode jsonl < cypher/validate.cypher
+//   cypherlite query --read-only --database <git-common-dir>/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,
-// edge shapes, coverage, acyclicity, and the data-flow (FROM) cut test.
+// edge shapes, coverage, acyclicity, the data-flow (FROM) cut test, and the
+// topics and owners of agent notes and symbols.
 CALL {
   MATCH (f:Feature) WITH count(f) AS c WHERE c <> 1
   RETURN 'feature-count' AS check, 'expected exactly 1 Feature node, found ' + toString(c) AS detail
 UNION ALL
-  MATCH (n) WHERE NOT (n:Feature OR n:Acceptance OR n:GbuildNode OR n:Field OR n:Review)
+  MATCH (n) WHERE NOT (n:Feature OR n:Acceptance OR n:GbuildNode OR n:Field OR n:Review OR n:Note OR n:Symbol)
   RETURN 'unknown-node' AS check, 'node with labels [' + reduce(s = '', l IN labels(n) | s + ' ' + l) + ' ] is not part of the gbuild model' AS detail
 UNION ALL
-  MATCH (n:GbuildNode) WHERE NOT n.slug =~ '^[a-z0-9]+(-[a-z0-9]+)*$'
-  RETURN 'bad-slug' AS check, n.slug + ': slug must be kebab-case' AS detail
+  MATCH (n:GbuildNode) WHERE NOT n.slug =~ '^[a-z0-9]+(-[a-z0-9]+)*$' OR n.slug IN ['tree', 'db', 'inbox']
+  RETURN 'bad-slug' AS check, n.slug + ': slug must be kebab-case and not tree, db or inbox' AS detail
 UNION ALL
   MATCH (n:GbuildNode) WHERE NOT n.type IN ['research', 'decision', 'code', 'test', 'verify', 'chore']
   RETURN 'bad-type' AS check, n.slug + ': invalid type ' + n.type AS detail
@@ -54,7 +55,9 @@ UNION ALL
           OR (type(r) = 'DEPENDS_ON' AND x:GbuildNode AND y:GbuildNode)
           OR (type(r) IN ['INPUT', 'OUTPUT'] AND x:GbuildNode AND y:Field)
           OR (type(r) = 'FROM' AND x:Field AND y:Field)
-          OR (type(r) = 'REVIEWED' AND x:GbuildNode AND y:Review))
+          OR (type(r) = 'REVIEWED' AND x:GbuildNode AND y:Review)
+          OR (type(r) = 'WROTE' AND x:GbuildNode AND y:Note)
+          OR (type(r) = 'DEFINES' AND x:GbuildNode AND y:Symbol))
   RETURN 'bad-edge' AS check,
          type(r) + ' from ' + coalesce(x.slug, x.id, x.name, '?') + ' to ' + coalesce(y.slug, y.id, y.name, '?') + ' is not an allowed edge' AS detail
 UNION ALL
@@ -100,6 +103,18 @@ UNION ALL
 UNION ALL
   MATCH (r:Review) WITH r, COUNT { (:GbuildNode)-[:REVIEWED]->(r) } AS c WHERE c <> 1
   RETURN 'review-owner' AS check, 'review attempt ' + toString(r.attempt) + ' has ' + toString(c) + ' owning nodes, want 1' AS detail
+UNION ALL
+  MATCH (nt:Note) WHERE NOT nt.topic IN ['setup', 'testing', 'conventions', 'gotcha'] OR trim(nt.text) = ''
+  RETURN 'bad-note' AS check, nt.by_node + ': note topic ' + nt.topic + ' must be setup, testing, conventions or gotcha, with non-blank text' AS detail
+UNION ALL
+  MATCH (nt:Note) WITH nt, COLLECT { MATCH (w:GbuildNode)-[:WROTE]->(nt) RETURN w.slug } AS by WHERE by <> [nt.by_node]
+  RETURN 'note-owner' AS check, nt.by_node + ': note must have exactly one WROTE edge, from the node named by by_node' AS detail
+UNION ALL
+  MATCH (s:Symbol) WHERE trim(s.name) = '' OR trim(s.file) = ''
+  RETURN 'bad-symbol' AS check, s.by_node + ': symbol needs a non-blank name and file' AS detail
+UNION ALL
+  MATCH (s:Symbol) WITH s, COLLECT { MATCH (w:GbuildNode)-[:DEFINES]->(s) RETURN w.slug } AS by WHERE by <> [s.by_node]
+  RETURN 'symbol-owner' AS check, s.by_node + '.' + s.name + ': symbol must have exactly one DEFINES edge, from the node named by by_node' AS detail
 }
 RETURN check, detail
 ORDER BY check, detail;

package/index.ts

@@ -29,17 +29,25 @@ const OPENCODE_NOTES = `
 You are running under OpenCode, not Claude Code. Apply these mappings to the
 instructions above:
 
-- \`Agent\`/\`Task\` tool dispatches (including run's per-node fan-out) use the
-  \`subagent\` tool. Fan-out stays real: one \`subagent\` call per frontier node,
-  all in a single message.
-- \`gbuild-reviewer\` and \`gbuild-auditor\` are not registered agents here. When
-  the instructions say to spawn one, dispatch the built-in \`general\` subagent
-  and start its prompt with the full text of
-  \`${join(root, "agents", "gbuild-reviewer.md")}\` (or
-  \`${join(root, "agents", "gbuild-auditor.md")}\`, minus the frontmatter) as its
-  instructions, followed by everything the instructions say to give it (node
-  definition, diff locations, expected verdict format). It is still a fresh,
-  isolated agent — never the one that implemented the node.
+- \`Agent\`/\`Task\` tool dispatches (including run's per-node dispatch) use the
+  \`subagent\` tool: one call per ready node, with \`background: true\` where
+  Claude Code says \`run_in_background: true\`. Handle each completion as it
+  arrives instead of waiting for a whole wave. The auditor runs in the
+  foreground (no background flag).
+- \`gbuild-implementer\`, \`gbuild-reviewer\` and \`gbuild-auditor\` are not
+  registered agents here. When the instructions say to spawn one, dispatch the
+  built-in \`general\` subagent instead:
+  - \`gbuild-implementer\` / \`gbuild-reviewer\`: the prompt is run's dispatch
+    template as written, prefixed with \`Read <Agent file> and follow it.\`,
+    where \`<Agent file>\` is the template's own \`Agent file:\` path
+    (\`${join(root, "agents", "gbuild-implementer.md")}\` /
+    \`${join(root, "agents", "gbuild-reviewer.md")}\`).
+  - \`gbuild-auditor\`: send
+    \`Read ${join(root, "agents", "gbuild-auditor.md")} and follow it.\`
+    followed by exactly what the review skill says to pass it.
+  Never paste the agent file's text into the prompt; the subagent reads it
+  itself. Each is still a fresh, isolated agent — a reviewer is never the one
+  that implemented the node.
 - \`$ARGUMENTS\` refers to the arguments this skill was invoked with in the
   conversation.
 - run's "Workflow tool" backend is Claude-specific; always use the fallback

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "opencode-gbuild",
-  "version": "0.7.1",
+  "version": "0.9.0",
   "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/checklist.md

@@ -1,6 +1,6 @@
 # Ship checklist
 
-`plan` runs this checklist against the graph it just wrote, before committing the store. Any item that
+`plan` runs this checklist against the graph it just wrote, before handing off to `run`. Any item that
 fails means revise the graph (with Cypher), not add a caveat in prose.
 
 1. **Risky assumptions are resolved, not deferred.** Every assumption that would invalidate nodes or