devague
Every feature starts as a vague idea, and most tooling rushes it straight to code. devague goes the other way: a small command-line tool that walks the idea backwards — from the announcement you wish you could make, to a spec you can defend, to a plan you can hand to a workforce — and then keeps score while the workforce builds, so what you ship is what you can prove.
Seven legs, one deterministic CLI, and a human gate at every point where a machine might otherwise grade its own work. This page is the tour, and the proof.
- installuv tool install devague
- repoagentculture/devague
- packagedevague · PyPI
- licenseApache-2.0
A vague idea in, an accountable delivery out — and no model in the middle
The arc is seven legs: scope the idea, think it backwards into a spec, challenge that spec for the blind spots it still hides, plan it forwards, fan the plan out to a workforce, stop for every deviation the build forces, then summarize what was actually delivered. Three engines share one CLI — the frame engine works backwards from the announcement, the plan engine works forwards from that spec, and the delivery ledger keeps score from the first departure to the final summary.
Here is the part that surprises people: there is no model inside. devague makes zero LLM calls — it is a small, deterministic, fully unit-tested Python CLI, not an agent, service, or daemon. Its state is plain JSON under .devague/ in the repo you are speccing. Your agent proposes; devague keeps score. That split is the whole design.
And the seam where execution begins is deliberate. The CLI describes the build — plan waves says what can run in parallel, plan deliverables says what exists once every task completes — and there its writ ends. Operators take over at the seam; devague follows the build from the ledger.
- ideaannouncement
- framecapture · confirm
- convergegate
- specexport
- challengeblind spots
- wavesplan
- buildworkforce
- deviateledger
- summaryartifact
idea → scope
the frame engine — before there is a framesurvey the surfaces the idea touches before framing it; each finding lands as first-class state citing what was actually read — provenance, not disclaimers
scope "<surface>" --finding · --seeds · --listidea → spec
the frame engineworks backwards from the announcement, capturing and pressure-testing every claim it makes
new · capture · interrogate · park · converge · exportspec → challenged spec
the frame engine — reopened by the passthe blind-spot hunt, scaled to risk: findings land proposed for the human through the existing moves; a clean pass records the lenses examined and the residual risk still parked — never a claim of no unknown unknowns
capture · interrogate · question · park · scope → reconverge · re-exportspec → plan
the plan engineworks forwards: tasks that cover every confirmed target, each with acceptance criteria and an honest dependency order — amendable without starting over
plan new · task · accept · depend · cover · amend · converge · exportplan → build
an operator — never the CLIthe execution seam: devague describes the dependency waves and the end state, deterministically; an operator performs the fan-out
plan waves · plan deliverables → parallel fan-outduring the build
the delivery ledgerthe moment execution must leave the confirmed plan, the run stops; the approved departure lands as an append-only record — never folded silently into drift
deviate · --confirm · --reject · --listafter the build
the delivery ledgerplanned versus actual, mid-work decisions, classified drift, evidence-backed claims, remaining work — rendered from state alone, on complete, partial, and failed runs
summary · summary --pr
Start from the announcement — pretend it already shipped
When the idea touches an existing codebase, the method opens before the announcement: scope. Survey the surfaces the idea reaches — code, docs, CI, the repos next door — and record each finding with what was actually read, so the frame starts seeded with provenance instead of guesses. It scales with the idea: small ones skip straight to the announcement, and no wizard insists.
The frame itself is called the announcement frame, and it opens with one question: pretend this shipped successfully — what would you announce? Every claim that announcement makes becomes an object devague can track.
You capture claims by kind — who it is for, what changed for them, what you are not promising. You interrogate each one: what must be true for this line to be honest? And when something is genuinely unknown, you do not paper over it — you park it, as first-class vagueness on the record.
Then the gate. converge lists every gap still standing between the frame and a spec, and export refuses to write one until the list is empty. Convergence has to mean something — otherwise the spec is just confident prose.
scope
what does this idea actually touch?
survey the surfaces before framing — findings land on the frame, each citing what was read
new
what are we saying shipped?
start a frame from the announcement
capture
what does the announcement claim?
record and classify a claim — audience, after-state, boundary, success signal
interrogate
what must be true for this to be honest?
attach honesty conditions and hard questions to a claim
park
what do we honestly not know yet?
record open vagueness as first-class state instead of forcing an answer
converge
is this solid enough to build from?
list every gap still standing between the frame and a spec
export
then, and only then —
write the buildable spec; refused until converge passes
The agent can never confirm its own proposal
devague is built for agent-driven development, and one rule is load-bearing: claims an LLM proposes land as proposed, and they stay proposed until a human confirms them. The agent can propose all day; it cannot confirm its own work. No fabricated rigor.
A rule like that only survives if it is ergonomic, so the loop is three commands. review writes a durable artifact listing every proposal awaiting a decision. You read it, mark each line confirm or reject, and apply it. And confirm is transactional — hand it one bad id and nothing changes at all.
And the rule does not stop at the spec. When a build must leave the confirmed plan, the run stops and the departure lands exactly the way a claim does: proposed if an agent raised it, approved only by you, classified acceptable, risky, or needs-follow-up. It is not a fourth gate — it is the owner of the plan gate amending it, one in-flight decision at a time, on an append-only ledger.
devague reviewwrites .devague/reviews/<slug>.md — a durable artifact of every proposal awaiting a human decision
devague confirm c2 h1 h3transactional — one bad id in the batch and nothing changes at all
devague confirm --from-review <file>applies the confirm/reject decisions from an edited review file
devague reject c3the other half of the gate — a rejected claim stays on the record as rejected, not deleted
devague deviate "…" --task t3 --origin llmmid-build, the same rule — an agent-raised deviation lands as proposed, with a reason and a classification, never as approved
devague deviate --confirm d1user-only, like every confirm — you approve that specific departure, or --reject it; either way it stays on the ledger
devague keeps score; operators make the moves
Around the CLI sit seven operator skills — authored in the devague repo, broadcast to the AgentCulture mesh — one per leg: /scope surveys before the frame, /think walks an idea to an exported spec, /challenge pressure-tests that exported spec for blind spots before planning, /spec-to-plan walks the challenged spec to an exported plan, /assign-to-workforce fans the plan out to a parallel workforce, /deviate stops the run when execution must leave the plan, and /summarize-delivery closes the loop.
Note what devague itself never does: orchestrate. devague plan waves only describes the dependency graph — deterministic metadata, nothing more. Spawning agents, managing worktrees, gating merges: that is the operator's job. The tool that keeps score should not also play the game.
/scope
idea → scopesurvey the surfaces the idea touches before framing — each finding lands on the frame citing what was actually read
/think
idea → specdrive the frame engine — announce, capture, interrogate, park; export once the frame converges
/challenge
between spec and planrun a risk-scaled blind-spot pass over the exported spec — findings land proposed for the human, and a clean pass records the lenses examined and the residual uncertainty, never a claim of no unknown unknowns
/spec-to-plan
spec → plandrive the plan engine — tasks that cover every confirmed target, with acceptance criteria and honest dependencies
/assign-to-workforce
plan → buildfan the plan's waves out to parallel agents in isolated git worktrees, with TDD-gated merges — the human owns three gates: the spec, the split plan, the final PR
/deviate
during the buildstop the run the moment execution must leave the plan; the approved departure lands on the ledger before work resumes
/summarize-delivery
after the buildrecord planned versus actual, mid-work decisions, classified drift, and evidence-backed claims — on complete, partial, and failed runs alike
This page specced itself — three times now
The sessions replayed below are not staged, and by now they tell three true stories. The first is the original run — the real frame and plan that specced and planned this very page, announcement to converge to export, then the plan leg through its dependency waves.
The second is the first catch-up, and it is a period piece now: it ran before the challenge leg existed, so its transcript honestly announces the method as it then stood — one leg shorter. When the page had to catch up with the tool, the tool ran its full arc on it: a scope survey before the frame, the convergence gate refusing an incomplete frame live, a user decision landing mid-session, a deviation put on the ledger, and the delivery-summary skeleton closing the loop.
The third is this update — the first to run the new seventh leg on its own frame. A lightweight challenge pass swept the exported spec for blind spots and surfaced one unstated assumption — the grid row the seventh skill card lands on — which the human confirmed on the record. The clean lenses went down as examined surfaces, the residual uncertainty was parked, and the same dated spec file was re-exported.
The gate has earned its keep in all three. In the first run, reality changed while the frame was open — and claims that were no longer true were rejected and re-captured, on the record. The human gate is real, not ceremony.
$ devague new "agentculture.org/agents/devague is live — a presentation-grade page introducing devague: the CLI that turns a vague idea into a buildable spec, then a buildable plan, by working backwards; the page presents the method (announcement frame, interrogation, convergence, human review loop), the command surface, real captured sessions, and a what's-next drawn from its issue tracker — good enough that Ori can present by just showing the page"
created frame 'agentculture-org-agents-devague-is-live-a-presenta' (announcement = c1)
$ devague capture --origin llm --kind audience "A live-presentation audience first: Ori presents and just shows this page while explaining. Secondarily, humans and agents browsing agentculture.org/agents/."
captured c2 (audience, proposed)
$ devague capture --origin llm --kind after_state "agentculture.org/agents/devague presents devague end to end: the idea-to-spec-to-plan pipeline, the announcement-frame method (capture, interrogate, park, converge, export), the human review loop (proposals stay proposed until a human confirms), the deterministic no-LLM CLI, the operator skills (/think, /spec-to-plan, /assign-to-workforce), real captured sessions, and a what's-next drawn from the open issue tracker. The /agents/ directory gains a devague card linking to the page."
captured c4 (after_state, proposed)
… (why_it_matters c5, boundary c6 captures elided)
$ devague capture --origin llm --kind success_signal "Same measurable floor as /agents/lobes: Lighthouse performance and accessibility >= 95 on the built page, light and dark themes both pass WCAG AA, animations compositor-only honoring prefers-reduced-motion, zero client-side network calls; plus an explicit presentable-as-is preview sign-off from Ori before merge/deploy."
captured c8 (success_signal, proposed)
$ devague capture --origin llm --kind decision "Centerpiece demo is the dogfood loop: the captured session shown on the page is the real devague frame that specced this very page — announcement to converge to export — so the page demonstrates the tool by exhibiting its own origin."
captured c13 (decision, proposed)
$ devague interrogate c10 --honesty "Viewed side by side with /agents/ and /agents/lobes in both light and dark themes, the page reads as the same site: same Layout/PageHero/Header/Footer, same tokens and fonts, no new global styles."
interrogated c10: honesty h2
$ devague interrogate c11 --honesty "Motion meets the established bar: compositor-only (transform/opacity), calm easing, 60fps, full prefers-reduced-motion path with a still-presentable static fallback; every replayed session was captured from a real run during authoring — anything not captured live is omitted or clearly marked illustrative."
interrogated c11: honesty h3
$ devague question "The devague repo is private but the package is public on PyPI (devague 0.17.1). Where does the devague card/page point for source: PyPI only, PyPI plus a 'source not yet public' note, or is making agentculture/devague public planned before this ships?"
wrote pending decision to .devague/questions/agentculture-org-agents-devague-is-live-a-presenta.md (uncommitted working state)
recorded q1
$ devague park "Exact set of open issues at authoring time — the what's-next themes get re-verified against the tracker when the page is written, since issues close and open between now and then." --kind unknown_nonblocking
parked v1 (unknown_nonblocking)
$ devague review
wrote review artifact to .devague/reviews/agentculture-org-agents-devague-is-live-a-presenta.md (unconfirmed, not authoritative)
… (mid-session: Ori made the repo public during review)
$ devague confirm c1 c2 c4 c5 c6 c7 c8 c10 c11 c13 c14 h2 h3 h5 h6
c1 -> confirmed
c2 -> confirmed
… (c4, c5, c6, c7, c8, c10, c11, c13, c14, h2, h3, h5 also confirmed)
h6 -> confirmed
$ devague reject c3 c9 c12 h1 h4 h7
c3 -> rejected
c9 -> rejected
c12 -> rejected
h1 -> rejected
h4 -> rejected
h7 -> rejected
$ devague question --resolve q1 --decision "Repo made public (Apache-2.0) on 2026-07-14, ahead of this page; the card and page link GitHub like every other /agents/ entry, with PyPI as the install artifact."
q1 -> resolved
$ devague capture --origin llm --kind before_state "agentculture.org does not mention devague anywhere: no directory entry on /agents/, no page. The repo agentculture/devague went public (Apache-2.0) on 2026-07-14, just ahead of this page; the package is on PyPI as devague 0.17.1."
captured c15 (before_state, proposed)
$ devague status
frame: agentculture-org-agents-devague-is-live-a-presenta (3 frames total)
convergence: NOT passed — 7 gap(s):
- claim c15 still proposed (confirm or reject it)
- claim c16 still proposed (confirm or reject it)
… (c17 still proposed; c2, c4, c6 gaps also listed)
- claim c8 has no confirmed honesty condition
recommended next move (first gap):
this is an LLM proposal — the USER decides: devague confirm c15 (or reject c15)
$ devague confirm c2 c4 c5 c6 c8 c15 c16 c17 h8 h9 h10 h11 h12 h13 h14
c2 -> confirmed
… (c4, c5, c6, c8, c15, c16, c17, h8 through h13 also confirmed)
h14 -> confirmed
$ devague converge
converged ✓
$ devague export
exported spec to docs/specs/2026-07-14-agentculture-org-agents-devague-is-live-a-presenta.md
$ devague plan new --frame agentculture-org-agents-devague-is-live-a-presenta
created plan 'agentculture-org-agents-devague-is-live-a-presenta' from frame 'agentculture-org-agents-devague-is-live-a-presenta' (22 coverage target(s))
$ devague plan task --origin llm "Capture real material: store this frame's own devague session transcripts as a typed data module (site-astro/src/data/devague-captures.ts) — the frame leg (new, capture, interrogate, review, confirm, status, converge, export) and the plan leg (plan new, task, cover, converge, waves, export), captured from real runs in this repo" --covers c11 --covers h3 --accept "Every captured line is from a real devague 0.17.1 run of this repo's own frame/plan session, stored verbatim (trimmed only for length), labeled with version and date; no secrets or private URLs in the stored file" --accept "Captures include both legs: the frame arc (new to export) and the plan arc (plan new to export), plus a status/converge gate moment showing proposed-vs-confirmed"
added t1 (proposed)
$ devague plan task --origin llm "Assemble the page (site-astro/src/pages/agents/devague.astro): Layout + PageHero + existing tokens and reveal pattern, rendering the content model with the diagram and terminal components in spoken-narrative order, one idea per viewport" --dep t2 --dep t3 --dep t4 --covers c10 --covers h2 --covers h12 --covers h6 --accept "Uses Layout/PageHero/Header/Footer and existing global tokens; no new global styles; builds clean with astro build" --accept "Sections follow the presentation arc top to bottom, one idea per viewport; every after_state element findable in one scroll pass"
added t5 (proposed)
… (tasks t2, t3, t4, t6, t7, t8, t9 added the same way)
$ devague plan risk "Deploy is a credentialed operator step (cultureflare) — timing depends on the operator being available after sign-off" --kind unknown_nonblocking --task t9
recorded risk r1 (unknown_nonblocking)
$ devague plan confirm t1
t1 -> confirmed
… (plan-level confirm takes one id per call — t2 through t9 confirmed the same way, nine calls in all)
$ devague plan converge
converged ✓
$ devague plan export
exported plan to docs/plans/2026-07-14-agentculture-org-agents-devague-is-live-a-presenta.md
$ devague plan waves
wave 0: t1, t2, t3, t6
wave 1: t4
wave 2: t5
wave 3: t7
wave 4: t8
wave 5: t9
$ devague new "agentculture.org/agents/devague now presents devague as the complete six-leg method — scope, think, spec-to-plan, assign-to-workforce, deviate, summarize-delivery — as a pure product presentation: the pipeline and method arc carry the execution seam (scope entries on the frame, the deviation ledger, the delivery summary), the operator-skills section shows all six legs, real captured sessions demonstrate the new legs, launch-day meta (public-since dates, dated version chips) is gone, and what's-next is re-verified against the live tracker — good enough that Ori presents the product by just showing the page" --title "devague page: six-leg update"
created frame 'devague-page-six-leg-update' (announcement = c1)
$ devague capture --origin llm --kind requirement "Pipeline, diagram, and skills copy reflect the devague 0.18 surface verified against the installed CLI and CHANGELOG: the scope verb (pre-frame scoping recorded on the frame), the deviate verb (append-only deviation ledger under .devague/deliveries/), the summary verb (render-only eight-section skeleton, --pr variant), and plan deliverables/amend."
captured c6 (requirement, proposed)
$ devague capture --origin llm --kind requirement "whatsNext is re-distilled from the live tracker at authoring time (gh issue list on agentculture/devague, 2026-07-15): the resolution-moves cluster (#60, #57, #55, #52, #49, #48, #45) and the consolidated board (#36) remain open; #62, #68, #69, #70 are closed and must not be linked as direction."
captured c15 (requirement, proposed)
… (c2–c5, c7–c14, c16–c18 captures elided)
$ devague scope "site-astro/src/data/devague.ts" --finding "carries all page copy: fact chips incl. 'public since 2026-07-14' and 'version 0.17.2 — 2026-07-14', the went-public hero paragraph, a 3-stage pipeline, 3 skill cards, and whatsNext linking #62/#68/#69/#70 — all closed by 0.18.0" --seeds c3 c5
recorded s1 (site-astro/src/data/devague.ts)
$ devague scope "devague 0.18.0 (devague --help; ../devague/CHANGELOG.md 0.18.0)" --finding "ships the scope, deviate, and summary verbs plus plan deliverables/amend; docs name the six-leg flow scope→think→spec-to-plan→assign-to-workforce→deviate→summarize-delivery" --seeds c6
recorded s2 (devague 0.18.0 (devague --help; ../devague/CHANGELOG.md 0.18.0))
$ devague scope "site-astro/src/data/devague-captures.ts" --finding "verbatim-replay contract: every line captured from a real run, cuts marked with first-class ellipsis lines, versions and dates carried as pane provenance — new panes must meet the same bar" --seeds c7 c10
recorded s3 (site-astro/src/data/devague-captures.ts)
$ devague scope --list
s1: site-astro/src/data/devague.ts -> carries all page copy: fact chips incl. 'public since 2026-07-14' and 'version 0.17.2 — 2026-07-14', the went-public hero paragraph, a 3-stage pipeline, 3 skill cards, and whatsNext linking #62/#68/#69/#70 — all closed by 0.18.0 [seeds: c3, c5]
s2: devague 0.18.0 (devague --help; ../devague/CHANGELOG.md 0.18.0) -> ships the scope, deviate, and summary verbs plus plan deliverables/amend; docs name the six-leg flow scope→think→spec-to-plan→assign-to-workforce→deviate→summarize-delivery [seeds: c6]
s3: site-astro/src/data/devague-captures.ts -> verbatim-replay contract: every line captured from a real run, cuts marked with first-class ellipsis lines, versions and dates carried as pane provenance — new panes must meet the same bar [seeds: c7, c10]
… (s4 through s8 — DevagueTerminal.astro, DevagueFlow.astro, the live issue tracker, docs/skill-sources.md, site.ts — cut for length)
$ devague confirm c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 c16 c17 c18 h1 h2 h3 h4 h5 h6 h7 h8
c1 -> confirmed
c2 -> confirmed
… (c3 through h7 confirmed the same way, 24 more lines)
h8 -> confirmed
$ devague converge
not converged:
- claim c2 has no confirmed honesty condition
- claim c3 has no confirmed honesty condition
… (c8, c9, c11 gaps also listed)
- claim c12 has no confirmed honesty condition
$ devague export
error: frame has not converged; cannot export
hint: resolve: claim c2 has no confirmed honesty condition; claim c3 has no confirmed honesty condition; claim c8 has no confirmed honesty condition; claim c9 has no confirmed honesty condition; claim c11 has no confirmed honesty condition; claim c12 has no confirmed honesty condition
$ devague capture --kind decision "Ori loves the page's animations: every existing animated beat is preserved, and the new steps get their own animated beats — the DevagueFlow arc's execution-seam stages animate in the same compositor-only language, and every new capture pane replays with the same typing/settle motion."
captured c19 (decision, confirmed)
$ devague confirm h9 h10 h11 h12 h13 h14
h9 -> confirmed
… (h10 through h13 confirmed the same way)
h14 -> confirmed
$ devague converge
converged ✓
$ devague export
exported spec to docs/specs/2026-07-14-devague-page-six-leg-update.md
$ devague --version
devague 0.18.0
$ devague deviate --list
no deviations recorded yet
$ devague summary
# Delivery Summary — devague page: six-leg update
plan: `devague-page-six-leg-update` · run: `<complete | partial | failed>` · date: `2026-07-14`
baseline: `devague plan (devague-page-six-leg-update)`
## Intent
> agentculture.org/agents/devague now presents devague as the complete six-leg method — scope, think, spec-to-plan, assign-to-workforce, deviate, summarize-delivery — as a pure product presentation: the pipeline and method arc carry the execution seam (scope entries on the frame, the deviation ledger, the delivery summary), the operator-skills section shows all six legs, real captured sessions demonstrate the new legs, launch-day meta (public-since dates, dated version chips) is gone, and what's-next is re-verified against the live tracker — good enough that Ori presents the product by just showing the page
… (## After, ## Planned Work — t1 through t7 — elided)
## Actual Delivery
| Plan task | Status | What actually landed |
… (rows `t1` through `t7`, each `<fill: status>` / `<fill: what landed>`, elided)
## Mid-work Decisions
(no deviations recorded yet)
## Drift From Plan
no approved deviation records yet — record drift via `devague deviate` before this section can be filled in
… (## Evidence, ## Delivery Claims sections — all `<fill: ...>` placeholders — elided)
## Remaining Work / Follow-up
- `<fill: remaining item>` — `<fill: next step / owner>`
$ devague capture --origin llm --kind assumption "the seventh skill card reads acceptably in the existing auto-fit grid (3+3+1); if it reads awkward at build time the task owner may give the row a deliberate treatment like the moves grid's full-width lead card — a styling call inside the task, not a new requirement"
captured c19 (assumption, proposed)
$ devague scope "challenge pass / unstated-assumptions lens: devague.astro skills grid CSS" --finding "the six cards sit 3+3; a seventh lands 3+3+1 with the last card alone — surfaced the layout assumption nobody had stated and proposed it for adjudication" --seeds c19
recorded s10 (challenge pass / unstated-assumptions lens: devague.astro skills grid CSS)
… (adjacent-systems lenses s11–s12 — DevagueFlow/DevagueTerminal imports, the site.ts directory entry — both clean; cut for length)
$ devague scope "challenge pass / operations+reversibility lens: .github/workflows/deploy.yml" --finding "merge to main auto-deploys site-astro/** to Cloudflare Pages (push-path trigger, secrets-gated, PR builds included) — the page goes live on merge with no separate operator step, and a git revert redeploys the old page; no rollback gap"
recorded s13 (challenge pass / operations+reversibility lens: .github/workflows/deploy.yml)
$ devague scope "challenge pass / cheap-probe lens: npm run build on the untouched tree" --finding "astro build exits 0 (6 pages, ~209ms) — c15's verification lane confirmed live before the workforce depends on it; dist/ is gitignored so the probe mutated nothing tracked"
recorded s14 (challenge pass / cheap-probe lens: npm run build on the untouched tree)
$ devague park "how the re-timed 9-stage cascade and raised stacking breakpoint read at mid-tablet widths is only observable in a browser during the build — residual until the flow task verifies it" --kind unknown_nonblocking
parked v1 (unknown_nonblocking)
$ devague scope "challenge pass / security+migration+concurrency+failure-modes lenses: the change surface as a class" --finding "statically-built page + verbatim skill vendor: no auth, no stored data, no schema, no concurrent writers; the only failure mode is a red build or an ugly render, both caught by c15's lane before merge — lenses examined, nothing to route"
recorded s15 (challenge pass / security+migration+concurrency+failure-modes lenses: the change surface as a class)
$ devague confirm c19
c19 -> confirmed
$ devague converge
converged ✓
… (seven non-blocking no-instruction warnings on descriptive claims — cut for length)
$ devague export
exported spec to docs/specs/2026-07-15-devague-page-the-challenge-leg.md
Transcripts are stored verbatim in a data module and replayed as text — the page never runs devague in your browser, and nothing is invented.
The tracker is public too — this is direction, not a promise
devague is small and moving, and its direction is checkable the same way its facts are: on the open tracker. Three themes stand out in the open issues.
Resolution moves
Parking vagueness is first-class; resolving it is not yet. A parked blocking unknown, or a claim's blocking hard question, can deadlock convergence with no CLI verb to release it — today that means hand-editing state. The largest open cluster is about giving resolution the same first-class treatment parking already has.
- #60 No verb to resolve parked vagueness (or edit task text) — operators hand-edit .devague state JSON
- #57 no unpark/resolve move: a parked unknown_blocking blocks convergence forever
- #55 No CLI verb to resolve parked vagueness (blocking vagueness can only be removed by editing frame state)
- #52 Add a CLI verb to resolve a claim's blocking hard question (convergence deadlock; unblocks /think exports)
- #48 Add a CLI verb to resolve blocking hard questions (converge is permanently blocked without one)
- #45 Add a move to reclassify/resolve a parked vagueness (unblocks /think convergence after a dependency is downgraded)
Views that tell the whole truth
What devague renders should carry everything its state knows. Today the exported spec still shows resolved hard questions as open and drops non-blocking parks, the think skill's docs point at paths that have since moved, and the plan engine knows waves, width, and per-task detail but shows them one verb at a time instead of one board.
- #49 export is lossy: shows resolved hard questions as open, drops unknown_nonblocking parks
- #47 think SKILL.md: After-export step documents stale frame/review paths (.devague/<slug>.json vs .devague/frames/, docs/reviews/ vs .devague/reviews/)
- #36 devague plan: render a consolidated wave/task board (waves, width, parallel-win, planned model, what-each-task-does)
Skills that travel
The operator skills are shipped software now, running on machines their authors do not control — and the open work reads like it: portability to macOS's older bash, interpreters resolved through uv instead of a bare python3, shell-lint findings, a downstream consumer's code review, and aligning the vendored outsource skill with devague's own setup.
- #37 assign-to-workforce: host-environment portability fixes (macOS bash 3.2 + remove agex/workflow.sh references)
- #41 assign-to-workforce.sh: resolve the Python interpreter via uv (don't call `python3` bare in split-plan)
- #42 Shell-lint: fix shelldre S7688/S7679 in assign-to-workforce/think/spec-to-plan scripts
- #40 Code review findings on operator skills (from a downstream consumer)
- #44 Align the vendored outsource skill to devague's setup
devague is open source, Apache-2.0, and deliberately small — a scorekeeper, not a player. It earned this page the honest way, three times over: the page was specced, planned, and built through the tool it presents, and this very update ran all seven legs, scope to delivery summary — including the challenge pass on its own spec. Every fact above traces to the public repo, PyPI, the open tracker, or the CLI's own output. Nothing was invented.