devague 0.14.0__tar.gz → 0.15.0__tar.gz

{devague-0.14.0 → devague-0.15.0}/.claude/skills/assign-to-workforce/SKILL.md

@@ -110,7 +110,13 @@ Once the human approves, the main agent fans out each wave in order:
 
 2. **Spawn a task agent** inside that worktree (using the approved model from
    the split plan), with:
-   - The task id, summary, and acceptance criteria as its brief.
+   - The task id, summary, acceptance criteria, and covered targets as its
+     brief — **quoted verbatim** from `devague plan show --json` (or the
+     exported plan-md). No operator paraphrasing: the plan text *is* the
+     contract the user confirmed, and a reworded brief silently drifts from it.
+     (When the enriched `waves --json` payload lands — devague#53, task t9 —
+     the brief comes straight from that one payload, per-task instructions
+     included.)
    - Instruction to work **test-first** (TDD): write the failing test(s) that
      match the acceptance criteria before implementing.
    - Instruction to commit its work to the worktree branch.
@@ -228,7 +234,9 @@ bash .claude/skills/cicd/scripts/workflow.sh open
 
 The exported plan-md from `devague plan export` is the standing brief for
 each task agent — its task id, summary, acceptance criteria, and the targets
-it covers are already in that file.
+it covers are already in that file. Quote those fields **verbatim** into each
+task agent's brief; the fan-out is honest only if what the subagent builds
+against is exactly what the user confirmed in the plan.
 
 ## Provenance
 

devague-0.15.0/.claude/skills/scope/SKILL.md

@@ -0,0 +1,132 @@
+---
+name: scope
+description: >
+  Explore the scope of a vague idea BEFORE framing it into a spec (the
+  idea→scope leg; the optional opening move ahead of /think). Survey the
+  surfaces the idea touches — code, docs, skills, CI, sibling repos — and seed
+  the coming Announcement Frame with boundary, non-goal, and assumption claims
+  that cite what was actually explored (provenance, not generic disclaimers).
+  Use when the user says "explore scope", "scope this idea", "what does this
+  touch", "map the scope", "scope exploration", or when an idea touches an
+  existing codebase and speccing it cold would mean guessing its boundaries.
+  Hand off to the sibling /think skill to build the frame. Authored and
+  maintained in agentculture/devague (origin = devague); guildmaster pulls this
+  skill from here and broadcasts it to the AgentCulture mesh — it is NOT
+  vendored from guildmaster like the inbound skills here.
+type: command
+---
+
+# scope — explore what an idea touches before you frame it
+
+The skill is named **`scope`**; it is the **opening leg** of the devague method
+— run it *before* the sibling **`/think`** skill frames an idea into a spec.
+Where `/think` converges on *what* to build, `/scope` grounds *where the idea
+lives*: which surfaces it touches, which it must not, and what is genuinely
+unknown — so the frame starts from explored territory instead of guesses.
+
+This comes from the sharper end-to-end method spec (devague#53): scope grounded
+up front means convergence measures real coverage instead of vibes. The
+exploration itself is **agent-side work** — the devague CLI stays deterministic
+and never explores anything (#20).
+
+## When to use — and when to skip
+
+Use `/scope` when the idea touches an existing codebase or ecosystem: a feature
+in a real repo, a process change across skills, anything where boundaries are
+discoverable rather than invented.
+
+**Skip it freely for small ideas.** Scope exploration is *not* a mandatory
+first stage — the move-driven adaptive arc stays intact, and an idea that fits
+in one announcement can go straight to `/think`. (This is a recorded non-goal
+of the method: no wizard.)
+
+## The method
+
+1. **Enumerate candidate surfaces.** List what the idea *might* touch: source
+   packages, CLI verbs, renderers, schemas, tests, docs, skills, CI workflows,
+   sibling repos. `git ls-files` and the repo's `CLAUDE.md` are the usual map.
+2. **Explore each surface read-only.** Read enough of each candidate to decide:
+   touched, not touched, or unknown. Exploration never mutates anything —
+   no edits, no state changes, no CLI moves yet.
+3. **Classify every finding.** Each explored surface yields one of:
+   - **in scope** — the idea changes it → becomes a `requirement` or
+     `assumption` claim in the frame;
+   - **out of scope** — the idea must not change it → becomes a `boundary` or
+     `non_goal` claim;
+   - **genuinely unknown** — can't tell without a decision → becomes a `park`
+     (open vagueness) or a `question` (pending user decision).
+4. **Seed the frame with provenance.** When `/think` starts, capture the
+   findings as claims whose text **cites the surface explored** — "the CLI
+   stays deterministic per issue 20; scope exploration is agent-side"
+   beats "we won't overreach". Provenance, not generic disclaimers: a reviewer
+   should be able to trace every boundary claim back to something you read.
+
+## How findings land (the shipped surface)
+
+There is no `devague scope` CLI verb yet — findings land through the existing
+`devague` moves (this skill invokes the CLI directly and stays self-contained;
+if `devague` isn't on your PATH: `uv tool install devague`):
+
+| Finding | Move |
+|---------|------|
+| in scope (the idea changes this) | `capture --kind requirement` / `--kind assumption` (with `--origin llm` if you proposed it) |
+| out of scope (must not change) | `capture --kind boundary` / `--kind non_goal` |
+| genuinely unknown, needs a user decision | `question "<text>"` (later `question --resolve <qid> --decision "<text>"`) |
+| genuinely unknown, not decidable now | `park "<text>" --kind unknown_blocking\|unknown_nonblocking` |
+
+A deterministic **`devague scope` move** — recording explored surfaces and
+findings as first-class frame state with provenance links — is **planned, not
+shipped**: it is task t3 of the committed sharper-end-to-end-method plan
+(`docs/plans/2026-07-01-devague-ships-a-sharper-end-to-end-method-a-guided.md`,
+devague#53). Do not run `devague scope` until it exists; this skill documents
+the surface as built.
+
+## Hard rules (do not violate)
+
+- **Exploration is read-only.** Surveying scope never edits files, never
+  mutates frame state, never runs a mutating CLI move.
+- **Provenance in every seeded claim.** A scope-derived claim cites what was
+  explored. If you didn't read it, don't claim it.
+- **LLM proposals stay proposed.** Findings you capture with `--origin llm`
+  land `proposed`; the user confirms. Same anti-fabrication contract as
+  `/think`.
+- **Don't become a wizard.** Scope exploration is optional-by-size and
+  adaptive. Never block a small idea on a survey it doesn't need.
+
+## Worked example
+
+Scoping "devague exports should carry per-item instructions" against the
+devague repo itself:
+
+```bash
+# 1–2. enumerate + explore (read-only)
+git ls-files devague/ | head -30       # the CLI package map
+# read: devague/frame.py (claim model), devague/render/spec_md.py (renderer),
+#       docs/spec-contract.md (schema contract), .claude/skills/think/SKILL.md
+
+# 3–4. hand off to /think and seed with provenance
+devague new "devague exports carry per-item instructions" --title "per-item instructions"
+devague capture --origin llm --kind requirement "claims gain an optional instruction field — devague/frame.py claim model + docs/spec-contract.md schema both need a bump"
+devague capture --origin llm --kind boundary "render/spec_md.py renders instructions verbatim; absent instructions render nothing — the renderer never fabricates filler"
+devague capture --origin llm --kind non_goal "no LLM calls land inside the CLI (issue 20) — instruction text is authored by the operator/user, never generated in-CLI"
+devague question "do instructions attach to frame claims, plan tasks, or both?"
+```
+
+Every claim above names the file or issue that was actually read — that is the
+provenance bar.
+
+## After scoping — hand off to /think
+
+Scope exploration produces no artifact of its own (until the planned CLI move
+lands, the findings *are* the seeded claims). When the survey is done, start
+the frame with `/think` and capture the findings as the frame's opening claims.
+The user confirms LLM-proposed ones there, as always.
+
+## Provenance
+
+This is a **first-party** skill — its origin is `agentculture/devague`, the
+*fourth* in the outbound family after `/think`, `/spec-to-plan`, and
+`/assign-to-workforce`, covering the pre-frame exploration leg. guildmaster
+pulls it from here and broadcasts it to the AgentCulture mesh. The
+`cite, don't import` policy still holds: downstream repos copy it, they don't
+symlink or depend on it. See `docs/skill-sources.md`.

{devague-0.14.0 → devague-0.15.0}/.claude/skills/spec-to-plan/SKILL.md

@@ -55,7 +55,7 @@ install hint. Every move — including `status` — is forwarded verbatim as
 | `accept <tN> "<crit>"` | Add an acceptance criterion to a task. |
 | `depend <tN> --on <tM>` | Record that task `tN` depends on `tM`. |
 | `cover <tN> --target <c*/h*>` | Mark a task as covering a coverage target. |
-| `confirm <tN>` / `reject <tN>` | Resolve a task. **User-only decision.** |
+| `confirm <tN>` / `reject <tN>` | Resolve a task. **User-only decision.** Takes **one task id per call** — loop for batches (unlike the frame engine's transactional multi-id `confirm`; parity is a recorded follow-up in the 2026-07-01 plan, devague#53). |
 | `risk "<text>" --kind <kind>` | Record a first-class plan risk (`--task <tN>` to attach). |
 | `converge` | Evaluate the gate against the **live** source frame; list remaining gaps. |
 | `export` | Write the buildable plan to `docs/plans/` — only after `converge` passes. |
@@ -119,6 +119,28 @@ When authoring a plan that will be built via parallel execution (fanned out to
 multiple agents via the downstream `/assign-to-workforce` skill), prefer the
 following discipline to maximize parallelism and minimize merge friction:
 
+### Acceptance criteria are the instruction contract (today)
+
+Until the planned per-task `instruction` field lands (task t5 of the
+sharper-end-to-end-method plan, devague#53), **acceptance criteria are where a
+task's working instructions live**. Write each criterion as something a cheaper
+model can execute test-first without re-deriving the design: name the files or
+modules the task owns, the observable behavior that proves it done, and the
+compatibility constraints ("pre-existing plans load with no error"). A criterion
+a subagent can't act on alone is a summary, not a contract. The enriched
+`waves --json` payload (carrying summary + instructions + acceptance criteria +
+covered targets per task) is planned in the same increment — until then, the
+brief is composed from `plan show --json` + the exported plan-md.
+
+### Text hygiene for exports
+
+The exported plan-md must pass markdown lint. The plan's H1 inherits the
+*frame's* title — set a short, period-free `--title` at `devague new` time (see
+`/think`'s export-hygiene rules). And backtick angle-bracket placeholders in
+task text (`` `instruct <tN>` ``, not `instruct <tN>`) — bare ones fail MD033.
+There is no task-edit move yet, so fixing text after confirmation means
+hand-editing state JSON.
+
 ### Small and crisply scoped
 
 Each task should be **small enough for a simpler or cheaper model to build

{devague-0.14.0 → devague-0.15.0}/.claude/skills/think/SKILL.md

@@ -37,6 +37,15 @@ This skill is the operator: a portable wrapper that resolves the CLI and
 forwards every move verbatim — including `status`, the read-only verb that reads
 the convergence gate and tells you the recommended next move.
 
+**Explore scope first when the idea touches an existing codebase.** The sibling
+**`/scope`** skill is the optional opening leg: survey the surfaces the idea
+touches *before* framing, then seed the frame with `boundary` / `non_goal` /
+`assumption` claims that cite what was actually explored (provenance, not
+generic disclaimers). Small ideas skip it and start here — no wizard. (From the
+sharper end-to-end method spec, devague#53; the deterministic `devague scope`
+move that will record findings as first-class state is planned there, not yet
+shipped.)
+
 ## How to run
 
 The entry point is `scripts/think.sh`. Invoke it from the repository you are
@@ -58,7 +67,7 @@ for portable resolution.
 
 | Move | What it does |
 |------|--------------|
-| `new "<announcement>"` | Start a frame from the announcement (the first move). Seeds an auto-confirmed `announcement` claim. |
+| `new "<announcement>" [--title "<short>"]` | Start a frame from the announcement (the first move). Seeds an auto-confirmed `announcement` claim. Always pass `--title` (see *Export hygiene*). |
 | `capture --kind <kind> "<text>"` | Record + classify a claim. `--origin llm` lands it as `proposed`. |
 | `interrogate <id> --honesty "…"` | Attach an honesty condition (what must be true). Also `--hard-question`, `--risk`, `--contradicts`, `--blocking`. |
 | `confirm <id> [<id>…]` / `reject <id> [<id>…]` | Resolve one or more claims (`c*`) / honesty conditions (`h*`) in one **transactional** call. **User-only decision.** Also `confirm --from-review <file>` to apply an edited review artifact. |
@@ -113,6 +122,34 @@ recommended next move (first gap):
 
 Run it whenever you're unsure what to do next.
 
+### Export hygiene — keep the artifacts lint-clean
+
+The exported spec-md must pass the repo's markdown lint. Two gotchas found by
+dogfooding (devague#53), both cheap to avoid up front and expensive after —
+there is no retitle/edit move yet, so fixing them later means hand-editing
+state JSON and re-exporting:
+
+- **Always pass `--title "<short title>"` to `new`.** The title becomes the H1
+  of every exported artifact (the plan inherits it too). The default is the
+  full announcement — long, and if it ends with a period the H1 fails MD026
+  (trailing punctuation). Keep the title short, no trailing period.
+- **Backtick angle-bracket tokens.** A placeholder like `--seeds <claim-id>`
+  in claim or honesty-condition text renders as inline HTML (MD033) unless
+  wrapped in backticks. Write `` `--seeds <claim-id>` ``, not the bare form.
+- **Lint before committing:** `markdownlint-cli2 "docs/specs/<file>.md"`.
+
+### Pending decisions — the `question` loop
+
+When a genuine design decision surfaces mid-frame, don't guess and don't stall:
+
+1. `question "<the decision to make>"` — records it as durable working state.
+2. Put it to the user (with concrete options where possible).
+3. `question --resolve <qid> --decision "<what the user chose>"`.
+4. `capture --kind decision "<the choice>"` — a user-origin capture
+   auto-confirms, making the decision a first-class frame claim.
+
+This keeps every user decision traceable from question → resolution → claim.
+
 ## Hard rules (do not violate)
 
 These are the point of the method — convergence must mean something.
@@ -149,7 +186,7 @@ A short end-to-end session (the kind you'd run to spec a feature like
 ```bash
 d() { bash .claude/skills/think/scripts/think.sh "$@"; }
 
-d new "Devague ships a documented spec contract"
+d new "Devague ships a documented spec contract" --title "documented spec contract"
 d capture --kind audience "devague + the assisting LLM"
 d capture --kind after_state "a vague idea becomes a buildable, pressure-tested spec"
 d capture --kind why_it_matters "specs converge on evidence, not vibes"

devague-0.15.0/.devague/current_plan

@@ -0,0 +1 @@
+devague-ships-a-sharper-end-to-end-method-a-guided

devague-0.15.0/.devague/frames/devague-ships-a-sharper-end-to-end-method-a-guided.json

@@ -0,0 +1,276 @@
+{
+  "slug": "devague-ships-a-sharper-end-to-end-method-a-guided",
+  "title": "devague ships a sharper end-to-end method",
+  "schema_version": 1,
+  "status": "exported",
+  "created": "2026-07-01T22:07:23Z",
+  "updated": "2026-07-01T22:32:01Z",
+  "claims": [
+    {
+      "id": "c1",
+      "kind": "announcement",
+      "text": "devague ships a sharper end-to-end method: a guided scope-exploration stage before the announcement frame, per-item instructions on every claim and task, sharper spec and plan exports, and a guided plan-to-fanout leg that carries those instructions to the workforce.",
+      "origin": "user",
+      "status": "confirmed",
+      "honesty_conditions": [
+        {
+          "id": "h1",
+          "text": "an operator can run idea to scope to spec to plan to fanout end-to-end and every handoff carries the per-item instructions without manual re-entry",
+          "status": "confirmed"
+        }
+      ],
+      "hard_questions": [
+        {
+          "id": "q1",
+          "text": "does the added scope stage slow the lightweight case \u2014 small ideas that today go announcement to converge in minutes?",
+          "resolved": false,
+          "blocking": false
+        }
+      ],
+      "links": []
+    },
+    {
+      "id": "c2",
+      "kind": "audience",
+      "text": "devague operators \u2014 the agent driving /think and /spec-to-plan \u2014 plus the humans who own the three gates, and the per-task workforce subagents who receive the instructions",
+      "origin": "llm",
+      "status": "confirmed",
+      "honesty_conditions": [
+        {
+          "id": "h7",
+          "text": "each named audience actually touches the shipped surface: the operator agent runs the new moves, the gate-owning humans review the sharper artifacts, and workforce subagents receive the instruction payloads",
+          "status": "confirmed"
+        }
+      ],
+      "hard_questions": [],
+      "links": []
+    },
+    {
+      "id": "c3",
+      "kind": "after_state",
+      "text": "an idea's scope is explored and mapped before the frame is built; every claim, honesty condition, and plan task can carry its own working instruction; exports read sharp \u2014 every item actionable, no boilerplate; and the plan-to-fanout leg hands the workforce per-task instructions instead of bare summaries",
+      "origin": "llm",
+      "status": "confirmed",
+      "honesty_conditions": [
+        {
+          "id": "h8",
+          "text": "the after-state is observable in one dogfooded run: a real idea goes scope, frame, sharper spec, plan, fanout using only the shipped surface",
+          "status": "confirmed"
+        }
+      ],
+      "hard_questions": [],
+      "links": []
+    },
+    {
+      "id": "c4",
+      "kind": "before_state",
+      "text": "today the frame starts cold at the announcement with no scope survey; claims and tasks carry only their summary text; exports leave the reader to re-derive how to act on each item; and plan waves emits task ids whose context assign-to-workforce must reconstruct by hand",
+      "origin": "llm",
+      "status": "confirmed",
+      "honesty_conditions": [
+        {
+          "id": "h9",
+          "text": "the before-state pains are citable gaps in today's code: no scope move exists, neither store has an instruction field, and assign-to-workforce reconstructs task context by hand",
+          "status": "confirmed"
+        }
+      ],
+      "hard_questions": [],
+      "links": []
+    },
+    {
+      "id": "c5",
+      "kind": "why_it_matters",
+      "text": "scope grounded up front means convergence measures real coverage instead of vibes, and per-item instructions make every exported artifact executable by a cheaper model without re-deriving the design",
+      "origin": "llm",
+      "status": "confirmed",
+      "honesty_conditions": [
+        {
+          "id": "h10",
+          "text": "coverage reported by the gate maps to scope that was actually explored \u2014 convergence measures explored territory, not just whatever text happened to be captured",
+          "status": "confirmed"
+        }
+      ],
+      "hard_questions": [],
+      "links": []
+    },
+    {
+      "id": "c6",
+      "kind": "boundary",
+      "text": "the CLI stays deterministic and non-orchestrating per issue 20: scope exploration is an agent/skill-side stage and fanout guidance lives in the assign-to-workforce skill \u2014 no LLM calls and no orchestration land inside the CLI",
+      "origin": "llm",
+      "status": "confirmed",
+      "honesty_conditions": [
+        {
+          "id": "h11",
+          "text": "the shipped diff contains no LLM calls, no subagent spawning, and no worktree management anywhere inside the devague package",
+          "status": "confirmed"
+        }
+      ],
+      "hard_questions": [],
+      "links": []
+    },
+    {
+      "id": "c7",
+      "kind": "non_goal",
+      "text": "not a wizard: scope exploration does not become a mandatory fixed first stage; the move-driven adaptive arc stays intact and small ideas can still skip straight to the announcement",
+      "origin": "llm",
+      "status": "confirmed",
+      "honesty_conditions": [],
+      "hard_questions": [],
+      "links": []
+    },
+    {
+      "id": "c8",
+      "kind": "success_signal",
+      "text": "a spec produced with the new process shows scope-exploration provenance on its boundary and non-goal claims; every exported plan task renders an instruction block; and an assign-to-workforce run consumes those instructions as the subagent brief without the operator re-typing context",
+      "origin": "llm",
+      "status": "confirmed",
+      "honesty_conditions": [
+        {
+          "id": "h12",
+          "text": "every success signal is checkable on artifacts alone: the exported spec shows scope provenance, the exported plan renders instruction blocks, and a fanout brief quotes them verbatim",
+          "status": "confirmed"
+        }
+      ],
+      "hard_questions": [],
+      "links": []
+    },
+    {
+      "id": "c9",
+      "kind": "requirement",
+      "text": "a scope-exploration stage precedes the frame: before or right after 'new', the operator surveys the repo/context the idea touches and the findings seed boundary, non-goal, and assumption claims that cite what was explored",
+      "origin": "llm",
+      "status": "confirmed",
+      "honesty_conditions": [
+        {
+          "id": "h2",
+          "text": "a frame built with scope exploration contains boundary and non-goal claims that cite the surfaces actually explored \u2014 provenance, not generic disclaimers",
+          "status": "confirmed"
+        }
+      ],
+      "hard_questions": [],
+      "links": []
+    },
+    {
+      "id": "c10",
+      "kind": "requirement",
+      "text": "claims and plan tasks accept an optional per-item instruction \u2014 how to verify or implement that item \u2014 stored in frame/plan state and rendered verbatim in exports; an absent instruction renders nothing",
+      "origin": "llm",
+      "status": "confirmed",
+      "honesty_conditions": [
+        {
+          "id": "h3",
+          "text": "instructions round-trip: capture, store, export renders them verbatim; an item without an instruction renders nothing rather than fabricated filler",
+          "status": "confirmed"
+        }
+      ],
+      "hard_questions": [
+        {
+          "id": "q2",
+          "text": "LLM-proposed instructions must stay proposed too \u2014 does the user confirm loop scale when every claim and task can carry one?",
+          "resolved": false,
+          "blocking": false
+        }
+      ],
+      "links": []
+    },
+    {
+      "id": "c11",
+      "kind": "requirement",
+      "text": "sharper exports: the rendered spec-md and plan-md make every item directly actionable, with the definition of sharper agreed with the user before build",
+      "origin": "llm",
+      "status": "confirmed",
+      "honesty_conditions": [
+        {
+          "id": "h4",
+          "text": "sharper has a written definition the user confirmed before any renderer change lands",
+          "status": "confirmed"
+        },
+        {
+          "id": "h6",
+          "text": "the tightened gate stays deterministic: it checks structural sharpness signals \u2014 instruction present on spec-affecting items, a measurable success signal, claim text meeting explicit structural rules \u2014 never LLM text judgment inside the CLI",
+          "status": "confirmed"
+        }
+      ],
+      "hard_questions": [
+        {
+          "id": "q3",
+          "text": "which structural checks can a deterministic CLI actually run to catch woolly text, and what is the false-positive story when they misfire on legitimate prose?",
+          "resolved": false,
+          "blocking": false
+        }
+      ],
+      "links": []
+    },
+    {
+      "id": "c12",
+      "kind": "requirement",
+      "text": "the plan-to-fanout leg is guided end-to-end: plan waves output carries each task's instruction and acceptance criteria, and the assign-to-workforce skill consumes that payload as the per-subagent brief",
+      "origin": "llm",
+      "status": "confirmed",
+      "honesty_conditions": [
+        {
+          "id": "h5",
+          "text": "an assign-to-workforce subagent receives its task's instruction and acceptance criteria in its brief with no operator paraphrasing required",
+          "status": "confirmed"
+        }
+      ],
+      "hard_questions": [],
+      "links": []
+    },
+    {
+      "id": "c13",
+      "kind": "assumption",
+      "text": "scope exploration is performed by the operating agent reading the repo and context \u2014 it adds no new CLI dependencies and no LLM calls inside devague",
+      "origin": "llm",
+      "status": "confirmed",
+      "honesty_conditions": [],
+      "hard_questions": [],
+      "links": []
+    },
+    {
+      "id": "c14",
+      "kind": "decision",
+      "text": "sharper results means both legs: exports render every item actionable with instruction blocks and no boilerplate, and the convergence gate tightens to flag vague untestable claim text",
+      "origin": "user",
+      "status": "confirmed",
+      "honesty_conditions": [],
+      "hard_questions": [],
+      "links": []
+    },
+    {
+      "id": "c15",
+      "kind": "decision",
+      "text": "scope exploration lands as a new deterministic CLI move \u2014 devague scope \u2014 that records explored surfaces and findings as first-class state with provenance; the operating agent performs the actual exploration",
+      "origin": "user",
+      "status": "confirmed",
+      "honesty_conditions": [],
+      "hard_questions": [],
+      "links": []
+    },
+    {
+      "id": "c16",
+      "kind": "decision",
+      "text": "per-item instructions attach to both frame claims and plan tasks via an optional instruction field, with a schema_version bump in both stores, flowing spec to plan to fanout",
+      "origin": "user",
+      "status": "confirmed",
+      "honesty_conditions": [],
+      "hard_questions": [],
+      "links": []
+    }
+  ],
+  "open_vagueness": [
+    {
+      "id": "v1",
+      "text": "the exact stored shape of the scope move's record \u2014 fields, provenance format, how findings link to the claims they seed",
+      "kind": "unknown_nonblocking",
+      "claim_id": "c15"
+    },
+    {
+      "id": "v2",
+      "text": "whether the tightened gate's structural checks land as blockers or as warnings first (a deprecation-style soft rollout)",
+      "kind": "unknown_nonblocking",
+      "claim_id": "c14"
+    }
+  ]
+}