devague 0.22.0__tar.gz → 0.24.0__tar.gz

{devague-0.22.0 → devague-0.24.0}/.claude/skills/assign-to-workforce/SKILL.md

@@ -282,28 +282,47 @@ Once all waves are merged and the full test suite passes, the main agent opens
 a PR via the `cicd` skill (`agex pr open`). The human reviews and merges. This
 is the last and only remaining human gate.
 
-## After the final PR — summarize the delivery
-
-Once the final PR is **merged**, close the execution loop cleanly instead of
-stopping at a green merge:
-
-1. **Summarize the delivery.** Run the sibling **`/summarize-delivery`** skill —
-   the delivery-side closure leg. It turns the run into a committed
-   accountability artifact (`docs/deliveries/<created-date>-<slug>.md`) that
-   records planned-versus-actual delivery, the mid-work decisions the workforce
-   made, where execution drifted from the plan, evidence-backed delivery claims
-   (a claim without evidence stays `unverified`, never asserted as done), and
-   any remaining work. The `devague plan waves --json` payload you fanned out is
-   the planned-work baseline it compares actuals against.
-2. **It closes partial and failed runs too.** `/summarize-delivery` does not
-   require every wave to have merged — a run that shipped only some tasks, or
-   none, still produces a truthful artifact: the failure lands under drift and
-   remaining work, and no claim says done without evidence.
+## Hand-offs: mid-run and after the final PR
+
+Two hand-offs bracket execution — one that can fire mid-run, one that always
+fires after the final PR merges:
+
+1. **Mid-run — hand off to `/deviate`.** If a task agent (or the main agent)
+   discovers the confirmed plan no longer matches reality partway through a
+   wave, that is not a silent edit to this run — stop, get explicit human
+   approval for the divergence, and record it via the sibling **`/deviate`**
+   skill (`devague deviate`) before resuming the fan-out. This is not a fourth
+   standing gate; it is the human owner of gate 2 approving an amendment to it
+   in-flight.
+2. **Post-merge — hand off to `/validate-delivery`, then `/summarize-delivery`.**
+   Once the final PR is **merged**, close the execution loop cleanly instead of
+   stopping at a green merge:
+   a. **Validate delivery.** Run the sibling **`/validate-delivery`** skill —
+      the execution-to-evidence leg. It runs the plan's behavioral tests
+      agent-side and files what it found (obligations met, evidence, and any
+      behavioral deltas) via the devague CLI; a failing or unchecked outcome is
+      filed and reported exactly as such, never rounded up.
+   b. **Summarize the delivery.** Run the sibling **`/summarize-delivery`**
+      skill — the delivery-side closure leg. It turns the run into a committed
+      accountability artifact (`docs/deliveries/<created-date>-<slug>.md`) that
+      records planned-versus-actual delivery, the mid-work decisions the
+      workforce made, where execution drifted from the plan, evidence-backed
+      delivery claims (a claim without evidence stays `unverified`, never
+      asserted as done — the strength ladder now draws on what
+      `/validate-delivery` filed), and any remaining work. The `devague plan
+      waves --json` payload you fanned out is the planned-work baseline it
+      compares actuals against.
+   c. **Both close partial and failed runs too.** Neither skill requires every
+      wave to have merged — a run that shipped only some tasks, or none, still
+      produces a truthful record: the failure lands under drift and remaining
+      work, and no claim says done without evidence.
 
 This is the accountability wrap-up after the three gates, not a fourth gate —
-`/summarize-delivery` is method-only and read-only (#20): it summarizes the run,
-it does not orchestrate, gate merges, or mutate devague state. Don't stop at
-"PR merged" — the standing flow is **merge, then `/summarize-delivery`**.
+`/deviate`, `/validate-delivery`, and `/summarize-delivery` are all method-only
+and record- or read-only (#20): none of them orchestrate, gate merges, or
+mutate devague state beyond their own append-only records. Don't stop at "PR
+merged" — the standing flow is **merge, then `/validate-delivery`, then
+`/summarize-delivery`**.
 
 ## Hard rules (do not violate)
 

{devague-0.22.0 → devague-0.24.0}/.claude/skills/assign-to-workforce/scripts/assign-to-workforce.sh

@@ -292,13 +292,28 @@ PY
     # extra read-only call (for the plan's `created`/`title`, to match the
     # date-prefixed filename convention `devague plan export` already uses).
     if [ "$write_mode" -eq 1 ]; then
-        local show_json show_rc
+        local show_json show_rc show_err show_tmp_err show_old_exit_trap
+        # A successful `devague plan show --json` now also emits a one-line
+        # `next: ...` stderr hint (next-leg-hints t1) — stderr must stay OFF
+        # the captured JSON string (a plain `2>&1` merge would corrupt it), so
+        # it is captured separately and only surfaced on a real failure,
+        # mirroring the `plan waves --json` capture above — including that
+        # capture's trap discipline: prior EXIT trap saved before mktemp,
+        # cleanup installed on the line after it, prior trap restored once the
+        # file is gone (PR #110 review).
+        show_old_exit_trap="$(trap -p EXIT)"
+        show_tmp_err="$(mktemp)"
+        trap 'rm -f "$show_tmp_err"' EXIT
         set +e
-        show_json="$("${DEVAGUE[@]}" plan show --json "${extra_args[@]}" 2>&1)"
+        show_json="$("${DEVAGUE[@]}" plan show --json "${extra_args[@]}" 2>"$show_tmp_err")"
         show_rc=$?
         set -e
+        show_err="$(cat "$show_tmp_err")"
+        rm -f "$show_tmp_err"
+        trap - EXIT
+        eval "${show_old_exit_trap}"  # empty string is a no-op; re-installs a prior trap if any
         if [ "$show_rc" -ne 0 ]; then
-            printf '%s\n' "$show_json" >&2
+            printf '%s\n' "$show_err" >&2
             return "$show_rc"
         fi
 

{devague-0.22.0 → devague-0.24.0}/.claude/skills/challenge/SKILL.md

@@ -24,7 +24,7 @@ the devague method — the *seventh* origin skill, sitting *third* in flow
 order, between the spec leg and the plan leg:
 
 ```text
-scope -> think -> challenge -> spec-to-plan -> assign-to-workforce -> deviate -> summarize-delivery
+scope -> think -> challenge -> spec-to-plan -> assign-to-workforce -> deviate -> validate-delivery -> summarize-delivery
 ```
 
 Before this leg existed, a frame could converge on precisely stated claims

{devague-0.22.0 → devague-0.24.0}/.claude/skills/deviate/SKILL.md

@@ -154,15 +154,17 @@ record would land `proposed` and need an explicit
 `devague deviate --confirm d1` from the user before `/summarize-delivery`
 could cite it as approved.
 
-## After recording — resume, then hand off to /summarize-delivery
+## After recording — resume, then hand off through /validate-delivery to /summarize-delivery
 
 Once the affected task briefs are adjusted and the fan-out resumes, nothing
 further is needed from this skill — the record already lives in the delivery
-store. When the run reaches `/summarize-delivery`, that skill's Drift From
-Plan and Mid-work Decisions sections quote these records by their `dN` id
-instead of reconstructing drift from memory, so the connective tissue between
-the confirmed plan and the delivery summary is the ledger this skill wrote,
-not anyone's recollection of the run.
+store. When the waves finish merging, the run continues through
+`/validate-delivery` (running the plan's behavioral tests and filing evidence
+and behavioral deltas) before it reaches `/summarize-delivery`. That skill's
+Drift From Plan and Mid-work Decisions sections quote these deviation records
+by their `dN` id instead of reconstructing drift from memory, so the
+connective tissue between the confirmed plan and the delivery summary is the
+ledger this skill wrote, not anyone's recollection of the run.
 
 ## Provenance
 

{devague-0.22.0 → devague-0.24.0}/.claude/skills/spec-to-plan/SKILL.md

@@ -305,6 +305,16 @@ The exported plan-md is a buildable artifact: topologically ordered tasks, each
 with acceptance criteria and the spec targets it covers. It feeds directly into
 implementation (or `superpowers:writing-plans`).
 
+## After the plan converges — hand off to /assign-to-workforce
+
+Once `converge` passes and `export` writes the plan-md, this leg is done.
+`devague plan waves --json` emits the dependency-graph plus the per-task brief
+(see above) as scheduling metadata — the single source the `/assign-to-workforce`
+skill needs to fan the plan's waves out to parallel subagents, get the human's
+go/no-go on the implementation split plan, and TDD-gate each merge. Continue
+with `/assign-to-workforce` next; if a fan-out mid-run needs to diverge from
+this plan, that is `/deviate`'s job, not a silent edit here.
+
 ## Provenance
 
 This is a **first-party** skill — its origin is `agentculture/devague`, where the

{devague-0.22.0 → devague-0.24.0}/.claude/skills/summarize-delivery/SKILL.md

@@ -451,9 +451,12 @@ produces the artifact the human reviews.
 ## Provenance
 
 This is a **first-party** skill — its origin is `agentculture/devague`, the
-*fifth* in the outbound family after `/scope`, `/think`, `/spec-to-plan`, and
-`/assign-to-workforce`, covering the delivery-side closure leg after a plan is
-executed. guildmaster pulls it from here and broadcasts it to the AgentCulture
+*fifth* in the outbound family chronologically (after `/think`,
+`/spec-to-plan`, `/assign-to-workforce`, and `/scope`), but the **terminal,
+eighth leg in flow order** — the closing skill of the full eight-leg family:
+`/scope` → `/think` → `/challenge` → `/spec-to-plan` → `/assign-to-workforce`
+→ `/deviate` → `/validate-delivery` → `/summarize-delivery`. guildmaster
+pulls it from here and broadcasts it to the AgentCulture
 mesh; because devague is upstream, it is **never re-vendored back** from
 guildmaster's re-broadcast copy. The `cite, don't import` policy still holds:
 downstream repos copy it, they don't symlink or depend on it. See

{devague-0.22.0 → devague-0.24.0}/.claude/skills/think/SKILL.md

@@ -280,13 +280,15 @@ idea→spec leg cleanly before moving on:
    claim — keep them together. (Per the repo's standing convention this normally
    becomes a branch + PR via the `cicd` skill; commit-only is fine when the user
    asks for it.)
-2. **Hand off to `/spec-to-plan`.** The forward leg is the sibling skill:
-   `devague plan new --frame <slug>` seeds a plan from the converged frame and
-   works it forward into a buildable plan (it can equally feed
-   `superpowers:writing-plans` or a normal implementation PR).
+2. **Hand off to `/challenge`, then `/spec-to-plan`.** The next leg is the
+   blind-spot pass: `/challenge` pressure-tests the exported frame before it
+   becomes a plan. Once that pass clears (or lands nothing new), the forward
+   leg is the sibling skill: `devague plan new --frame <slug>` seeds a plan
+   from the converged frame and works it forward into a buildable plan (it can
+   equally feed `superpowers:writing-plans` or a normal implementation PR).
 
 Don't pause for a "what next?" menu after a reviewed export — the standing flow
-is **commit, then `/spec-to-plan`**.
+is **commit, then `/challenge`, then `/spec-to-plan`**.
 
 ## Provenance
 

devague-0.24.0/.claude/skills/validate-delivery/SKILL.md

@@ -0,0 +1,227 @@
+---
+name: validate-delivery
+description: >
+  Run the confirmed plan's behavioral tests agent-side after
+  assign-to-workforce merges its waves and before summarize-delivery closes
+  the loop, then file what was found — evidence for what passed, behavioral
+  deltas for what the run added, amended, or removed — as first-class,
+  record-only entries via the devague CLI. Never runs the tests inside the
+  CLI (issue #20); never suppresses a failing or partial outcome. Use when
+  the user says "validate delivery", "run behavioral tests", "check what
+  actually behaves", "file evidence", "record a behavioral delta", or after
+  assign-to-workforce merges (or fails to merge) a plan's waves and before
+  summarize-delivery runs. 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
+---
+
+# validate-delivery — run behavioral tests, file evidence and deltas
+
+The skill is named **`validate-delivery`**; it is the **execution-to-evidence
+leg** of the devague method — the *seventh* leg in flow order (the *eighth*
+origin skill, chronologically), sitting between the two closing execution
+skills:
+
+```text
+scope -> think -> challenge -> spec-to-plan -> assign-to-workforce ->
+deviate -> validate-delivery -> summarize-delivery
+```
+
+Where `/assign-to-workforce` fans out a converged plan's waves and
+`/summarize-delivery` closes the loop afterward, `/validate-delivery` runs
+**after waves merge and before the delivery summary is written**. It is the
+gap that used to be filled by memory: the confirmed plan's claims are
+obligations, and until this skill existed nothing forced the run to check
+whether the merged code actually behaves as claimed before the summary
+asserted it did.
+
+## When to invoke
+
+Run this skill once a wave (or the whole plan) has merged and there is
+behavior to check against a claim or an approved deviation — always before
+`/summarize-delivery`, never as a substitute for it. It is not gated on a
+complete run: a partial or failed fan-out is still worth validating for
+whatever did merge.
+
+## The method
+
+1. **Identify the obligations.** Read the plan's confirmed claims (via the
+   frame) and any approved `/deviate` records to see what the run promised —
+   an announcement, an after-state, a success signal, an acceptance
+   criterion. Each one that has a behavioral test backing it is an
+   obligation this leg checks.
+2. **Locate the behavioral tests.** Consuming repos identify behavioral
+   tests one of two ways (either is valid; pick whichever the repo already
+   uses, and say which one in the filed evidence):
+   - a **pytest marker**, e.g. `@pytest.mark.behavioral` — run with
+     `pytest -m behavioral`;
+   - a **dedicated folder**, e.g. `tests/behavioral/` or
+     `behavioral-tests/` — run that path directly.
+3. **Run the tests agent-side.** The agent (not the devague CLI) executes
+   the behavioral test suite, or the specific tests relevant to the
+   obligations in scope. This is read-only against the codebase — it does
+   not modify code to make a test pass.
+4. **File evidence for every obligation checked.** For each obligation, file
+   an evidence record naming the obligation met, the test that asserted the
+   behavior, and the outcome — `pass` or `fail`. A failing outcome is filed
+   exactly like a passing one; it is never omitted or reworded into
+   something softer.
+5. **File behavioral deltas for what changed.** When the run's actual
+   behavior added, amended, or removed a behavior relative to the plan, file
+   a delta record — `added` / `amended` / `removed` — with provenance back
+   to the claim or approved deviation that motivated it, and forward to the
+   evidence record(s) that back it.
+6. **Report faithfully.** Summarize what was validated, what passed, what
+   failed, and what could not be checked at all (no behavioral test exists
+   for that obligation yet). An unmet obligation is unmet — it is reported
+   as such, not folded into a passing tally or left out of the report.
+7. **Hand off to `/summarize-delivery`.** The filed evidence and deltas feed
+   directly into `devague summary`'s Delivery Claims table: evidence
+   strength (coverage / fidelity / execution / sensitivity) is the
+   confidence vocabulary there, and any approved lapse on a claim caps its
+   confidence the same way it always has.
+
+## The CLI surface this skill drives
+
+**Record-only.** The devague CLI never runs a test itself (issue
+[#20](https://github.com/agentculture/devague/issues/20)) — it only records
+what the agent already ran and found. The exact verb shapes below are
+minimal placeholders while the underlying schema lands in a parallel task;
+treat the verb names as stable and the flags as illustrative, and reconcile
+against `devague explain <move>` once that task merges.
+
+| Move | What it records |
+|------|------------------|
+| `devague oblige <cN> --seam "<seam>" --behavior "<behavior>"` | Files a behavioral obligation against a claim, naming the seam to test and the behavior to assert (snapshots the claim text at filing). |
+| `devague evidence --obligation <oN> --test "<ref>" --behavior "<asserted>" --contract "<claim text>" --type <type> --strength <level> --basis "<basis>" --outcome pass\|fail [--run-commit <sha> --run-timestamp <ts>]` | Files an evidence record: obligation met by this test, asserting this behavior, outcome pass or fail (a run reference is required at execution strength and above). `llm`-origin filings land `proposed`; the human adjudicates. |
+| `devague delta --kind added\|amended\|removed --behavior "<what changed>" --caused-by <cN\|dN> [--evidence <eN> ...]` | Files a behavioral delta: provenance back to the claim/deviation it diverges from (`--caused-by`), forward to the evidence that backs it. |
+| `devague summary [--pr] [--json]` | Reads the filed evidence and deltas back into the Delivery Claims table (`/summarize-delivery`'s starting point). |
+
+`--origin llm` on `oblige` / `evidence` / `delta` lands the record `proposed`
+— exactly the same anti-fabrication contract as `deviate` and `lapse`: an
+agent's own filing never self-confirms, and only the human's `--confirm` /
+`--reject` moves a proposed record forward. A `user`-origin filing
+auto-approves, mirroring `deviate` and `lapse`.
+
+## Hard rules (do not violate)
+
+- **The CLI never runs tests.** `devague oblige` / `evidence` / `delta` are
+  record-only moves — they take the agent's already-obtained result and
+  file it. Running the suite is the agent's job, agent-side, exactly like
+  `/summarize-delivery`'s read-only verification step (issue #20).
+- **Unmet is unmet.** A failing or unchecked obligation is filed and
+  reported as failing or unchecked — never smoothed into "mostly passing" or
+  silently dropped from the report. This is the direct fix for the
+  motivating failure below: findings discovered only by reading data after
+  the fact, never by a test failing loudly in the record.
+- **A partial or failed run is still a valid input.** There is no
+  completion precondition — validate whatever merged, report the rest as
+  not yet checkable.
+- **`llm`-origin filings stay proposed until the user confirms.** Same
+  anti-fabrication contract as every other origin vocabulary in this
+  method — an agent's own proposal never self-confirms.
+- **Provenance both ways.** Every evidence record ties back to an obligation
+  (a claim or an approved deviation); every delta ties back to what it
+  diverges from and forward to the evidence that backs it. An untraceable
+  evidence or delta record is not filed.
+- **This is not a new gate.** Like `/deviate`, `/validate-delivery` does not
+  add a fourth standing human gate — it produces the record `/summarize-
+  delivery` and the final PR review consume; the three gates (spec,
+  implementation split plan, final PR) are unchanged.
+
+## Worked example
+
+Wave 2 of a plan merged the `export --format widget-md` verb. The plan's
+confirmed `success_signal` claim `c9` said "round-tripping a widget through
+`export` and back loses no fields." A behavioral test exists for it,
+marked `@pytest.mark.behavioral`, plus two more behavioral tests for
+adjacent claims — one of which fails.
+
+```bash
+# 1. Identify the obligation (echoes its id, e.g. o1)
+devague oblige c9 --seam "widget export round-trip" \
+  --behavior "round-tripping a widget loses no fields"
+
+# 2. Locate and run the behavioral tests agent-side (read-only)
+pytest -m behavioral -q
+# -> tests/behavioral/test_widget_export.py::test_round_trip PASSED
+# -> tests/behavioral/test_widget_export.py::test_empty_field_rendering FAILED
+
+# 3. File evidence for each outcome — the failure included, not smoothed over
+devague evidence --obligation o1 \
+  --test tests/behavioral/test_widget_export.py::test_round_trip \
+  --behavior "asserts an exported-then-reimported widget compares equal field by field" \
+  --contract "round-tripping a widget loses no fields" \
+  --type automated --strength execution \
+  --basis "behavioral test ran green at the named commit" \
+  --outcome pass --run-commit abc1234 --run-timestamp 2026-08-31T12:00:00
+devague evidence --obligation o2 \
+  --test tests/behavioral/test_widget_export.py::test_empty_field_rendering \
+  --behavior "asserts an absent widget field renders as an empty line" \
+  --contract "an absent field renders honestly, never as filler" \
+  --type automated --strength execution \
+  --basis "behavioral test ran red at the named commit" \
+  --outcome fail --run-commit abc1234 --run-timestamp 2026-08-31T12:00:00
+
+# 4. File a delta if the failure reveals a real behavioral divergence
+devague delta --kind amended \
+  --behavior "empty widget fields render as garbled text, not an empty line" \
+  --caused-by c11 --evidence e2
+
+# 5. Report faithfully: c9 is validated; c11's claimed behavior is unmet —
+#    say so plainly, hand it to /summarize-delivery as Remaining Work, not
+#    as a passing claim.
+```
+
+`/summarize-delivery` then reads these back — `c9`'s Delivery Claims row
+cites evidence `e1` at `high` confidence (a passing behavioral test); `c11`'s
+row is `unverified` or explicitly failing, never rounded up.
+
+## After validating — hand off to /summarize-delivery
+
+Once every obligation in scope has an evidence record (or is reported as not
+yet checkable) and any behavioral deltas are filed, this leg is done — there
+is nothing separate to export, the filed records already live in devague
+state. Continue with the sibling **`/summarize-delivery`** skill: its
+Delivery Claims table reads the evidence and deltas filed here directly
+(`devague summary`), so the confidence a claim carries in the final delivery
+artifact traces back to a test that actually ran, not to memory. Don't stop
+at "tests ran" — the standing flow is **file the evidence, then
+`/summarize-delivery`**.
+
+## The motivating record
+
+The Reasoning Degradation Ledger (`devague lapse`, issue
+[`agentculture/devague#97`](https://github.com/agentculture/devague/issues/97))
+exists because of this, cited verbatim: "Four graders failed in that
+cycle... Every one was found by reading data afterwards; none by a test
+failing." That gap — a corrections record reconstructed only at the end,
+from memory, because nothing forced a behavioral check to run and be filed
+along the way — is exactly what `/validate-delivery` closes for the
+*execution* side, the same way `/challenge` closes it for the *spec* side.
+
+The design itself traces to issue
+[`agentculture/devague#107`](https://github.com/agentculture/devague/issues/107),
+"Suggestion: behavioral validation and a derived current spec," which
+proposed behavior as the primary contract, four evidence types, a strength
+ladder, and the current spec as a projection of a behavior ledger rather
+than a hand-maintained document. This skill is the method-only front door to
+that idea: it does not implement the full ledger or the derived-spec
+projection — it establishes where in the flow behavioral checking happens,
+what gets filed, and how the failure mode #97 documented gets closed instead
+of rediscovered.
+
+## Provenance
+
+This is a **first-party** skill — its origin is `agentculture/devague`, the
+*eighth* in the outbound family after `/scope`, `/think`, `/challenge`,
+`/spec-to-plan`, `/assign-to-workforce`, `/deviate`, and
+`/summarize-delivery`, covering the execution-to-evidence leg that runs
+after a plan's waves merge and before the delivery summary is written.
+guildmaster pulls it from here and broadcasts it to the AgentCulture mesh;
+because devague is upstream, it is **never re-vendored back** from
+guildmaster's re-broadcast copy. 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.24.0/.devague/current_plan

@@ -0,0 +1 @@
+next-leg-hints

devague-0.24.0/.devague/deliveries/behavior-validation-and-today-spec.json

@@ -0,0 +1,108 @@
+{
+  "plan_slug": "behavior-validation-and-today-spec",
+  "schema_version": 2,
+  "created": "2026-08-31T18:27:51Z",
+  "updated": "2026-08-31T18:41:30Z",
+  "deviations": [],
+  "evidence": [
+    {
+      "id": "e1",
+      "obligation_ref": "o1",
+      "test_ref": "tests/test_obligation_warnings.py",
+      "behavior_text": "asserts converge and plan converge emit a warning naming the obligation id and seam when no approved evidence exists, that proposed or superseded evidence does not discharge it, and that ready flags and lapse exclusions are untouched",
+      "contract_text": "an obligation with no approved evidence emits a visibly-untested warning naming the obligation and its seam, and ready_for_spec / ready_for_plan stay untouched",
+      "evidence_type": "automated",
+      "strength": "execution",
+      "strength_basis": "29-test behavioral file ran green at the named commit in the run just recorded; assertions read and matched against the obligation text",
+      "outcome": "pass",
+      "run": {
+        "timestamp": "2026-08-31T21:27:40+03:00",
+        "commit": "3945fb7"
+      },
+      "origin": "llm",
+      "status": "approved",
+      "superseded": false
+    },
+    {
+      "id": "e2",
+      "obligation_ref": "o2",
+      "test_ref": "tests/test_today.py + tests/test_today_cli.py",
+      "behavior_text": "asserts the projection loads every frame, plan, and delivery fail-open with diagnostics, that devague today writes docs/current-spec.md and every other file hashes byte-identical before and after, and that the same stores project to the same bytes",
+      "contract_text": "the projection walks every frame, plan, and delivery fail-open, writes only docs/current-spec.md, and leaves every store file byte-identical",
+      "evidence_type": "automated",
+      "strength": "execution",
+      "strength_basis": "52 behavioral tests ran green at the named commit, including the hash-everything-before-and-after pin and two determinism pins",
+      "outcome": "pass",
+      "run": {
+        "timestamp": "2026-08-31T21:27:40+03:00",
+        "commit": "3945fb7"
+      },
+      "origin": "llm",
+      "status": "approved",
+      "superseded": false
+    },
+    {
+      "id": "e3",
+      "obligation_ref": "o3",
+      "test_ref": "tests/test_summary_delivery_claims.py",
+      "behavior_text": "asserts one Delivery Claims row per obligation-bearing claim with ladder strength from best approved passing evidence, failing evidence rendered as FAILING, proposed as pending, and approved lapses capping rendered strength with most-restrictive-wins",
+      "contract_text": "one row per obligation-bearing claim renders ladder strength from approved passing evidence, with approved lapses capping renderable strength",
+      "evidence_type": "automated",
+      "strength": "execution",
+      "strength_basis": "25-test behavioral file ran green at the named commit; cap mapping and row-state assertions read directly",
+      "outcome": "pass",
+      "run": {
+        "timestamp": "2026-08-31T21:27:40+03:00",
+        "commit": "3945fb7"
+      },
+      "origin": "llm",
+      "status": "approved",
+      "superseded": false
+    }
+  ],
+  "deltas": [
+    {
+      "id": "b1",
+      "kind": "added",
+      "behavior_text": "converge and plan converge warn on behavioral obligations with no approved evidence \u2014 visibly untested, never gating",
+      "caused_by": [
+        "c6"
+      ],
+      "evidence_refs": [
+        "e1"
+      ],
+      "origin": "llm",
+      "status": "approved",
+      "superseded": false
+    },
+    {
+      "id": "b2",
+      "kind": "added",
+      "behavior_text": "devague today projects the behavior ledger across all frames, plans, and deliveries into the committed docs/current-spec.md, fail-open and read-only over stores",
+      "caused_by": [
+        "c7"
+      ],
+      "evidence_refs": [
+        "e2"
+      ],
+      "origin": "llm",
+      "status": "approved",
+      "superseded": false
+    },
+    {
+      "id": "b3",
+      "kind": "added",
+      "behavior_text": "devague summary's Delivery Claims table renders per-claim evidence strength on the coverage/fidelity/execution/sensitivity ladder, capped by approved lapses",
+      "caused_by": [
+        "c20"
+      ],
+      "evidence_refs": [
+        "e3"
+      ],
+      "origin": "llm",
+      "status": "approved",
+      "superseded": false
+    }
+  ],
+  "supersessions": []
+}