devague 0.4.1__tar.gz → 0.5.1__tar.gz

{devague-0.4.1 → devague-0.5.1}/.claude/skills/spec-to-plan/scripts/spec-to-plan.sh

@@ -108,7 +108,6 @@ cmd_status() {
         python3 - <<'PY'
 import json
 import os
-import re
 import sys
 
 
@@ -154,52 +153,25 @@ if conv is None:
     print("next move: devague plan show     # inspect the plan")
     sys.exit(0)
 
-if conv.get("passed"):
+if conv.get("ready_for_plan"):
     print("convergence: PASSED ✓")
+    for w in conv.get("warnings") or []:
+        print(f"  ⚠ {w}")
     print("next move: devague plan export   # write the buildable plan")
     sys.exit(0)
 
-missing = conv.get("missing") or []
-print(f"convergence: NOT passed — {len(missing)} gap(s):")
-for gap in missing:
-    print(f"  - {gap}")
-
-
-def suggest(gap):
-    if "no tasks yet" in gap:
-        return 'devague plan task "<summary>" --covers <c*/h*> --accept "<criterion>"'
-    m = re.search(r"coverage target (\w+) ", gap)
-    if m:
-        tid = m.group(1)
-        return (
-            f'cover {tid}: devague plan task "<summary>" --covers {tid} --accept "<...>"'
-            f"   (or: devague plan cover <tN> --target {tid})"
-        )
-    m = re.search(r"task (t\d+) has no acceptance", gap)
-    if m:
-        return f'devague plan accept {m.group(1)} "<acceptance criterion>"'
-    m = re.search(r"task (t\d+) still proposed", gap)
-    if m:
-        tid = m.group(1)
-        return (
-            f"this is an LLM proposal — the USER decides:"
-            f" devague plan confirm {tid}   (or: devague plan reject {tid})"
-        )
-    m = re.search(r"task (t\d+) depends on unknown task (t\d+)", gap)
-    if m:
-        return f"fix {m.group(1)}'s dependency on missing {m.group(2)} (add it, or drop the dep)"
-    if "dependency cycle" in gap:
-        return "break the dependency cycle: re-point one task's --dep so the graph is acyclic"
-    m = re.search(r"blocking risk (r\d+)", gap)
-    if m:
-        return f"resolve {m.group(1)}: cover it with a task, or re-record it as non-blocking"
-    return "devague plan show     # inspect and decide"
-
-
-if missing:
+blockers = conv.get("blockers") or []
+print(f"convergence: NOT passed — {len(blockers)} gap(s):")
+for b in blockers:
+    print(f"  - {b}")
+for w in conv.get("warnings") or []:
+    print(f"  ⚠ {w}")
+
+moves = conv.get("required_next_moves") or []
+if moves:
     print()
     print("recommended next move (first gap):")
-    print(f"  {suggest(missing[0])}")
+    print(f"  {moves[0]}")
 PY
 }
 

{devague-0.4.1 → devague-0.5.1}/.claude/skills/think/SKILL.md

@@ -66,27 +66,31 @@ portable resolution and the `status` helper.
 | `learn` / `explain <move>` | Teach the method / explain one move. |
 
 Claim kinds: `announcement`, `audience`, `after_state`, `before_state`,
-`why_it_matters`, `boundary`, `success_signal`, `open_question`. Vagueness kinds:
-`unknown_nonblocking`, `unknown_blocking`, `out_of_scope`, `follow_up`.
+`why_it_matters`, `boundary`, `success_signal`, `open_question`, `non_goal`,
+`requirement`, `assumption`, `decision`. Vagueness kinds: `unknown_nonblocking`,
+`unknown_blocking`, `out_of_scope`, `follow_up`.
 
 These are exactly the kinds the **shipped CLI enforces** (`CLAIM_KINDS` /
 `VAGUENESS_KINDS` in `devague/frame.py`) — the skill documents the surface as
-built, so every command here passes the CLI's `choices=` validation. A fuller
-proposed type/state set, plus the formal per-move input/output/transition
-contract, is tracked on the CLI side in
-[#5](https://github.com/agentculture/devague/issues/5); for the authoritative
+built, so every command here passes the CLI's `choices=` validation. `requirement`
+is spec-affecting (needs a confirmed honesty condition); `non_goal` / `decision`
+are descriptive; an unconfirmed `assumption` is a convergence *warning*, not a
+blocker. The formal entity model, the `(state × origin)` vocabulary, and the
+per-move input/output/transition/error contract are documented in
+[`docs/spec-contract.md`](../../../docs/spec-contract.md) (issue
+[#5](https://github.com/agentculture/devague/issues/5)); for the authoritative
 live shape of any move, run it with `--json` (or `devague learn --json` /
-`devague explain <move>`). When the CLI's contract grows, re-sync this list.
+`devague explain <move>`).
 
 ### `status` — the next-move helper
 
 `status` is a wrapper-only verb (the CLI has no `status`). It reads
 `converge --json` + `list --json` and prints where the current frame stands, the
-remaining gaps, and the recommended next move derived from the first gap.
-`converge --json` currently emits `{passed, missing}`, which is what the helper
-consumes; if [#5](https://github.com/agentculture/devague/issues/5) enriches that
-payload (e.g. structured `blockers` / `warnings` / `required_next_moves`),
-`status` will surface the richer fields then.
+remaining gaps, and the recommended next move. `converge --json` emits the
+structured result `{ready_for_spec, blockers, warnings, parked_items,
+required_next_moves}` (issue [#5](https://github.com/agentculture/devague/issues/5));
+the helper reads `ready_for_spec`, lists the `blockers` and `warnings`, and shows
+`required_next_moves[0]` as the recommended move — no longer deriving it itself.
 
 ```text
 frame: my-feature    (1 frame total)

{devague-0.4.1 → devague-0.5.1}/.claude/skills/think/scripts/think.sh

@@ -114,7 +114,6 @@ cmd_status() {
         python3 - <<'PY'
 import json
 import os
-import re
 import sys
 
 
@@ -161,58 +160,25 @@ if conv is None:
     print("next move: devague show     # inspect the frame")
     sys.exit(0)
 
-if conv.get("passed"):
+if conv.get("ready_for_spec"):
     print("convergence: PASSED ✓")
+    for w in conv.get("warnings") or []:
+        print(f"  ⚠ {w}")
     print("next move: devague export   # write the buildable spec")
     sys.exit(0)
 
-missing = conv.get("missing") or []
-print(f"convergence: NOT passed — {len(missing)} gap(s):")
-for gap in missing:
-    print(f"  - {gap}")
-
-
-def suggest(gap):
-    # Confirmation is a USER-only transition; a plain (user-origin) capture
-    # is already confirmed, so never imply the agent should confirm its own
-    # work. Spell out who confirms wherever a confirm is in play.
-    m = re.search(r"missing confirmed '([a-z_]+)' claim", gap)
-    if m:
-        kind = m.group(1)
-        return (f'devague capture --kind {kind} "<text>"'
-                f'   (a user capture auto-confirms; an --origin llm capture'
-                f' then needs the USER to confirm it)')
-    if "before_state" in gap and "why_it_matters" in gap:
-        return 'devague capture --kind why_it_matters "<text>"'
-    if "boundary" in gap:
-        return 'devague capture --kind boundary "<text>"'
-    if "success_signal" in gap:
-        return 'devague capture --kind success_signal "<text>"'
-    m = re.search(r"claim (c\d+) still proposed", gap)
-    if m:
-        cid = m.group(1)
-        return (f'this is an LLM proposal — the USER decides:'
-                f' devague confirm {cid}   (or: devague reject {cid})')
-    m = re.search(r"claim (c\d+) has no confirmed honesty condition", gap)
-    if m:
-        cid = m.group(1)
-        return (f'devague interrogate {cid} --honesty "<what must be true>"'
-                f'   then the USER runs: devague confirm <hN>')
-    m = re.search(r"blocking vagueness (v\d+)", gap)
-    if m:
-        return (f"resolve {m.group(1)}: capture+confirm the answer, "
-                f"or re-park it as non-blocking")
-    m = re.search(r"blocking hard question (q\d+) on (c\d+)", gap)
-    if m:
-        return (f"resolve {m.group(1)} on {m.group(2)}: answer it, then "
-                f"capture/confirm the resulting claim")
-    return "devague show     # inspect and decide"
-
-
-if missing:
+blockers = conv.get("blockers") or []
+print(f"convergence: NOT passed — {len(blockers)} gap(s):")
+for b in blockers:
+    print(f"  - {b}")
+for w in conv.get("warnings") or []:
+    print(f"  ⚠ {w}")
+
+moves = conv.get("required_next_moves") or []
+if moves:
     print()
     print("recommended next move (first gap):")
-    print(f"  {suggest(missing[0])}")
+    print(f"  {moves[0]}")
 PY
 }
 

devague-0.5.1/.devague/current_plan

@@ -0,0 +1 @@
+devague-0-6-0-ships-the-human-review-loop-devague

devague-0.5.1/.devague/frames/devague-0-6-0-ships-the-human-review-loop-devague.json

@@ -0,0 +1,299 @@
+{
+  "slug": "devague-0-6-0-ships-the-human-review-loop-devague",
+  "title": "devague 0.6.0 ships the Human Review Loop: 'devague review' surfaces every unconfirmed LLM proposal in one pass, and confirm/reject now take many ids at once \u2014 so honest human review scales to frames full of proposals without ever auto-confirming anything.",
+  "schema_version": 1,
+  "status": "exported",
+  "created": "2026-05-23T11:07:38Z",
+  "updated": "2026-05-23T11:24:24Z",
+  "claims": [
+    {
+      "id": "c1",
+      "kind": "announcement",
+      "text": "devague 0.6.0 ships the Human Review Loop: 'devague review' surfaces every unconfirmed LLM proposal in one pass, and confirm/reject now take many ids at once \u2014 so honest human review scales to frames full of proposals without ever auto-confirming anything.",
+      "origin": "user",
+      "status": "confirmed",
+      "honesty_conditions": [
+        {
+          "id": "h6",
+          "text": "At 0.6.0 release the announcement is literally true of the shipped CLI: 'devague review' exists, and a frame full of proposed items can be reviewed then bulk confirmed/rejected in one pass with no path that auto-confirms.",
+          "status": "confirmed"
+        }
+      ],
+      "hard_questions": [],
+      "links": []
+    },
+    {
+      "id": "c2",
+      "kind": "audience",
+      "text": "The human operator driving devague who must review and confirm/reject LLM-proposed claims and honesty conditions, plus the assisting LLM agent that produces those proposals.",
+      "origin": "user",
+      "status": "confirmed",
+      "honesty_conditions": [
+        {
+          "id": "h7",
+          "text": "Both audiences are served: the operator gets a single review + bulk-decide path, and the LLM agent's proposals stay visibly 'proposed' until the operator explicitly acts.",
+          "status": "confirmed"
+        }
+      ],
+      "hard_questions": [],
+      "links": []
+    },
+    {
+      "id": "c3",
+      "kind": "after_state",
+      "text": "In one pass the operator sees every unconfirmed proposal (proposed claims + proposed honesty conditions) without the frame needing to converge, then confirms or rejects many in a single command; pending design questions persist as durable .devague working state to decide later.",
+      "origin": "user",
+      "status": "confirmed",
+      "honesty_conditions": [
+        {
+          "id": "h8",
+          "text": "On a non-converged frame, one 'review' shows every proposed item and one 'confirm'/'reject' call resolves a chosen set \u2014 demonstrable end-to-end in a test.",
+          "status": "confirmed"
+        }
+      ],
+      "hard_questions": [],
+      "links": []
+    },
+    {
+      "id": "c4",
+      "kind": "before_state",
+      "text": "Review was ad-hoc (hand-rolled from show / show --json) and confirmation was one id per command, so a frame with ~15 proposed conditions meant 15 sequential commands \u2014 pushing toward rubber-stamping instead of genuine review (surfaced dogfooding /think on #5).",
+      "origin": "user",
+      "status": "confirmed",
+      "honesty_conditions": [
+        {
+          "id": "h9",
+          "text": "The before-state pain is real and removed: the pre-0.6.0 flow needed N commands for N conditions with no review artifact; 0.6.0 replaces that with one review plus one bulk decision.",
+          "status": "confirmed"
+        }
+      ],
+      "hard_questions": [],
+      "links": []
+    },
+    {
+      "id": "c5",
+      "kind": "why_it_matters",
+      "text": "The user-only confirmation step is devague's whole anti-fabrication guarantee; it must be ergonomic enough to do honestly at scale and support out-of-band review (read proposals somewhere comfortable like NotebookLM or a shared doc, then apply decisions), or it gets skipped or rubber-stamped.",
+      "origin": "user",
+      "status": "confirmed",
+      "honesty_conditions": [
+        {
+          "id": "h10",
+          "text": "The anti-fabrication guarantee is preserved exactly: ergonomics improve but no proposal becomes authoritative without an explicit user action, asserted by test.",
+          "status": "confirmed"
+        }
+      ],
+      "hard_questions": [],
+      "links": []
+    },
+    {
+      "id": "c6",
+      "kind": "success_signal",
+      "text": "A frame with many proposed items is reviewed and resolved in a single 'devague review' plus one batched confirm/reject, and the test suite proves: review export works before convergence, multi-id confirm/reject works, and no review-flow command auto-confirms a proposal.",
+      "origin": "user",
+      "status": "confirmed",
+      "honesty_conditions": [
+        {
+          "id": "h11",
+          "text": "The success signals are verified by the committed test suite, not asserted by hand.",
+          "status": "confirmed"
+        }
+      ],
+      "hard_questions": [],
+      "links": []
+    },
+    {
+      "id": "c7",
+      "kind": "boundary",
+      "text": "Scope is the review/confirm UX layered over the existing proposed-vs-confirmed contract (#5/#16); it does not change the state model itself \u2014 proposals still only become authoritative by explicit user action.",
+      "origin": "user",
+      "status": "confirmed",
+      "honesty_conditions": [
+        {
+          "id": "h12",
+          "text": "0.6.0 adds only review/confirm UX; the proposed-vs-confirmed state model and convergence gate from #5/#16 are unchanged \u2014 no new claim or condition states are introduced.",
+          "status": "confirmed"
+        }
+      ],
+      "hard_questions": [],
+      "links": []
+    },
+    {
+      "id": "c8",
+      "kind": "non_goal",
+      "text": "Does not generate a polished buildable spec from unconfirmed review output \u2014 review output stays explicitly non-authoritative, distinct from what 'export' produces post-convergence.",
+      "origin": "user",
+      "status": "confirmed",
+      "honesty_conditions": [],
+      "hard_questions": [],
+      "links": []
+    },
+    {
+      "id": "c9",
+      "kind": "non_goal",
+      "text": "Does not auto-resolve questions and does not auto-confirm any LLM-proposed content anywhere in the review flow.",
+      "origin": "user",
+      "status": "confirmed",
+      "honesty_conditions": [],
+      "hard_questions": [],
+      "links": []
+    },
+    {
+      "id": "c10",
+      "kind": "non_goal",
+      "text": "The CLI does not call an LLM.",
+      "origin": "user",
+      "status": "confirmed",
+      "honesty_conditions": [],
+      "hard_questions": [],
+      "links": []
+    },
+    {
+      "id": "c11",
+      "kind": "non_goal",
+      "text": "Does not require GitHub, NotebookLM, or any external service.",
+      "origin": "user",
+      "status": "confirmed",
+      "honesty_conditions": [],
+      "hard_questions": [],
+      "links": []
+    },
+    {
+      "id": "c12",
+      "kind": "requirement",
+      "text": "'devague review' (and 'devague review --json') emits all proposed claims and proposed honesty conditions, with their ids, without requiring or triggering convergence.",
+      "origin": "user",
+      "status": "confirmed",
+      "honesty_conditions": [
+        {
+          "id": "h1",
+          "text": "Running 'devague review' on a frame that has NOT converged still exits 0 and lists every proposed claim and proposed honesty condition with ids; it never invokes the convergence gate nor mutates any claim/condition state.",
+          "status": "confirmed"
+        }
+      ],
+      "hard_questions": [],
+      "links": []
+    },
+    {
+      "id": "c13",
+      "kind": "requirement",
+      "text": "Review output is clearly labelled unconfirmed and non-authoritative, visually distinct from the buildable spec that 'export' produces only after convergence.",
+      "origin": "user",
+      "status": "confirmed",
+      "honesty_conditions": [
+        {
+          "id": "h2",
+          "text": "The review artifact carries an explicit 'nothing confirmed yet \u2014 non-authoritative' banner and is written to a path under .devague/reviews/<slug>.md, distinct from docs/specs/, so it cannot be mistaken for the buildable spec.",
+          "status": "confirmed"
+        }
+      ],
+      "hard_questions": [],
+      "links": []
+    },
+    {
+      "id": "c14",
+      "kind": "requirement",
+      "text": "'devague confirm' accepts multiple claim/honesty ids in one invocation, and 'devague reject' likewise.",
+      "origin": "user",
+      "status": "confirmed",
+      "honesty_conditions": [
+        {
+          "id": "h3",
+          "text": "'devague confirm a b c' resolves every listed id in a single call (and 'reject a b c' likewise), and the handling of a batch containing an invalid/unknown id follows one defined, tested rule.",
+          "status": "confirmed"
+        }
+      ],
+      "hard_questions": [],
+      "links": []
+    },
+    {
+      "id": "c15",
+      "kind": "requirement",
+      "text": "Open questions / pending user decisions can be written as durable .devague working state (e.g. .devague/questions/<slug>.md), treated as uncommitted working state by default unless the user intentionally promotes one into docs.",
+      "origin": "user",
+      "status": "confirmed",
+      "honesty_conditions": [
+        {
+          "id": "h4",
+          "text": "A pending question the CLI writes persists across runs under .devague/questions/<slug>.md, is treated as uncommitted working state by default, and a documented path exists to apply a confirmed decision back into the frame.",
+          "status": "confirmed"
+        }
+      ],
+      "hard_questions": [],
+      "links": []
+    },
+    {
+      "id": "c16",
+      "kind": "requirement",
+      "text": "No command in the review flow auto-confirms LLM-proposed content; every confirm/reject stays an explicit user action.",
+      "origin": "user",
+      "status": "confirmed",
+      "honesty_conditions": [
+        {
+          "id": "h5",
+          "text": "An automated test asserts that no review-flow command (review, multi-id confirm/reject, any --json path) transitions an llm-origin proposed item to confirmed without an explicit user confirm naming that id.",
+          "status": "confirmed"
+        }
+      ],
+      "hard_questions": [],
+      "links": []
+    },
+    {
+      "id": "c17",
+      "kind": "decision",
+      "text": "Batch confirm/reject is TRANSACTIONAL: validate all ids first; if any id is unknown/invalid, resolve none and exit non-zero with a hint \u2014 never a half-applied batch.",
+      "origin": "user",
+      "status": "confirmed",
+      "honesty_conditions": [],
+      "hard_questions": [],
+      "links": []
+    },
+    {
+      "id": "c18",
+      "kind": "decision",
+      "text": "'devague confirm --from-review <file>' IS in scope for 0.6.0: it parses a reviewed decision set (confirm/reject per id) from the review artifact and applies it, so the review artifact format must be documented and round-trippable.",
+      "origin": "user",
+      "status": "confirmed",
+      "honesty_conditions": [],
+      "hard_questions": [],
+      "links": []
+    },
+    {
+      "id": "c19",
+      "kind": "decision",
+      "text": "devague manages .gitignore: it ensures .devague/reviews/ and .devague/questions/ are git-ignored so review/question state is uncommitted working state by default; the user opts in to promote one into docs.",
+      "origin": "user",
+      "status": "confirmed",
+      "honesty_conditions": [],
+      "hard_questions": [],
+      "links": []
+    },
+    {
+      "id": "c20",
+      "kind": "decision",
+      "text": "Pending questions/decisions are produced by a CLI move that writes .devague/questions/<slug>.md and owns the format (first-class + unit-testable), not a hand-written skill artifact.",
+      "origin": "user",
+      "status": "confirmed",
+      "honesty_conditions": [],
+      "hard_questions": [],
+      "links": []
+    },
+    {
+      "id": "c21",
+      "kind": "requirement",
+      "text": "'devague confirm --from-review <file>' applies a reviewed decision set parsed from the review artifact; the artifact 'devague review' emits is documented and round-trippable (review -> edit decisions -> apply).",
+      "origin": "user",
+      "status": "confirmed",
+      "honesty_conditions": [
+        {
+          "id": "h13",
+          "text": "A review artifact emitted by 'devague review' can be edited with confirm/reject decisions and fed to 'devague confirm --from-review <file>' to apply exactly those decisions \u2014 proven by a round-trip test \u2014 and applying it still auto-confirms nothing the file did not mark confirmed.",
+          "status": "confirmed"
+        }
+      ],
+      "hard_questions": [],
+      "links": []
+    }
+  ],
+  "open_vagueness": []
+}