Prompt index by plugin

Every example prompt shipped by the 13 plugin READMEs, 106 in total, collected on one page. This is the plugin-indexed view; for the task-indexed view — which skill fires at which moment of a piece of work — see the prompt catalog.

This page is generated from the plugin READMEs by tools/prompt-index/build_prompt_index.py and tracked as an artifact, so it cannot drift from them. Edit the prompts in their own README, never here.

andon

plugins/andon/README.md — 6 prompts.

Check readiness first

"run andon-preflight against this repo"

Triggers andon-preflight — read-only readiness report (stage legibility, ledger writability, house-rules presence); never creates the ledger.

Start hardening

"harden this repo, one gap at a time"

Triggers andon-loop — detects the value stream, proposes and verifies a fix for the current stage's gap, and halts rather than advancing past a broken or unproven wire.

Check the board

"what does the andon board look like right now"

Triggers andon-status — read-only: stream table, cursor, pass/cycle counters, open gap counts; nothing advances.

Propose a fix

"propose a fix for this gap, only ask where it actually matters"

Triggers andon-propose — proposes maximally from the ledger/codebase/house-rules, then grills you one question at a time, only on genuinely load-bearing forks.

Prove a wire

"prove this wire is actually proven"

Triggers andon-verify — routes the wire to one of seven evidence-grounded strategies and returns a structured green/red verdict.

Resume a paused pass

"resume the andon ledger from where we left off"

Triggers andon-loop — continues an existing ledger's cycle rather than starting fresh, still refusing to advance past whatever gap stopped the last pass.

arbeitsplan

plugins/arbeitsplan/README.md — 9 prompts.

Turn a vague piece of work into something runnable

"I know roughly what I want to change but not how to actually run it as an agentic workflow — turn it into one"

Triggers arbeitsplan-compile: scopes the problem, derives acceptance criteria with real commands, picks patterns from the frozen catalog, sets a dispatch budget, and writes workflow.json. Refuses and points at zirkel if the problem turns out to be a question.

Build several versions and keep the best one

"build three independent versions of this change and land whichever one actually holds up"

Triggers arbeitsplan-run: one worktree per candidate over the same scope, a blind referee per candidate, exactly one diff applied, the losers deleted. Nothing is merged.

Ask what shape the work should take

"how many agents should I actually use for this, and when does it stop?"

Triggers arbeitsplan-patterns: names a pattern, a fan-out width, a model tier, a stop rule and a cost, each tagged with whether the number was measured or reasoned.

Compare with and without a plugin, on fresh processes

"run this same prompt three times with the plugin and three times without, on separate processes"

Triggers arbeitsplan-matrix: compiles a cases × models × plugin_states × repeats sweep, proves the environment can authenticate with one cheap call, then runs it — one fresh process per cell, with a real per-cell --model.

Find out where to even start

"which workflow fits fixing this bug, what do I need to install, and should I use plan mode?"

Triggers arbeitsplan-start: matches the task to one of the four approved workflows in references/approved-workflows.md, names the plugins still missing with their exact install command, and states the permission mode to run in. Recommend-only — it never installs anything or writes workflow.json itself. "No fit" is a valid answer.

Decide how the work should run

"should this run as a workflow of parallel agents, a matrix of fresh processes, or just in this session?"

Triggers arbeitsplan-backend: walks the decision table in references/backend-selection.md and returns the backend object workflow.json needs — the kind, the table rows that chose it, and the acknowledged gap when it is workflow. Refuses workflow for any phase that writes the shared tree. Recommend-only.

Find out why something was refused

"the swarm just stopped and said the contract is wrong — what happened?"

Triggers arbeitsplan-status: reads the run's run.jsonl — phases closed and open, a halt with its reason, refuted candidates, open doubts, budget used, whether a lock is still open — and quotes the single next command.

Design the workflow before running it

"before anything runs, walk me through this workflow step by step — what each step does, where it runs, when, and on which model"

Triggers arbeitsplan-design: builds the design table node by node in plan mode, writes every command in the repository's own toolchain (a gate or a state helper becomes a declared script node, in whatever language the project uses), validates it with compile_spec.py --design, preflights each toolchain, and asks for approval against the design's sha256. Then prints the handoff — launch in a later turn than the install whenever the design created agent types, or in a fresh session with the exact start prompt it prints.

Run a restructuring in waves

"this refactor is several waves of parallel work, each building on the last — set it up so it can stop and resume"

Triggers arbeitsplan-waves: installs the approved wave design as project-owned files — a pinned interpreter, the plan, a state helper, a guard, one agent file per role — and runs it from the primary checkout. A red gate stops it with the target unmoved; a relaunch skips every finished wave and builder.

befund

plugins/befund/README.md — 16 prompts.

Map the architecture

"map this repo's architecture"

Triggers befund-stage-map — import-graph-based stage/wire detection, not naive directory guessing.

Run the auto-pilot

"run the auto-pilot"

Triggers befund-autopilot — full check → plan → gate → fix/validate, gated behind explicit settings before anything is written.

Check status

"where does befund stand"

Triggers befund-status — read-only board of what's been run and what's stale.

Sweep a portfolio

"sweep our whole portfolio of repos"

Triggers befund-portfolio — multi-repo dashboard, graded worst-signal-wins.

Check readiness first

"can befund actually analyze this codebase?"

Triggers befund-preflight — verifies language detection, tool availability, house-rules presence, and git/CI presence, then assigns a Ready/Ready-with-gaps/ Not-ready verdict per downstream skill.

Find architecture problems

"find god-modules or dependency cycles in this codebase"

Triggers befund-arch-health — reads the stage graph from befund-stage-map and confirms every candidate god-module or cycle against actual code, not just the graph.

Audit git/CI setup

"check our git remotes and CI setup for redundant mirrors"

Triggers befund-ci-topology — audits remote topology and CI config for redundancy and mirror risk, masking every credential to a short preview.

Find modernization opportunities

"find deprecated idioms and code smells in this repo"

Triggers befund-code-idiom — judges idioms against the actual language version declared in the repo's own manifest, never a fixed list, and separates fixable modernization from judgment-requiring smells.

Score complexity per module

"which module needs attention first? score complexity per stage"

Triggers befund-complexity-score — computes a relative complexity index (2.94 × KSLOC^1.10) per stage, and lists unmeasured stages plainly rather than inventing numbers.

Check documentation accuracy

"does our README still match what the code actually does?"

Triggers befund-docs-drift — extracts falsifiable claims from CLAUDE.md/README/ADRs and verifies each one against the cited code.

Mine the hidden business rules

"document the domain rules hidden in this code as testable specs"

Triggers befund-extract-rules — mines calculations, validations, and state transitions into Given/When/Then rules, looping to convergence and requiring a scored judge verdict to pass for any P0 rule.

Apply the modernization findings

"apply the modernization findings befund-code-idiom found"

Triggers befund-idiom-fix — applies only eligible modernization-category findings, gated behind idiom_fix.mode: fix, one remediator dispatch per (file, kind) cluster, then hands off to andon-verify unverified.

Check our own conventions

"audit this code against our house rules"

Triggers befund-lint-audit — extracts discrete rules from .claude/house-rules.md (or CLAUDE.md as a fallback) and verifies violations, capped at lint_max_rules dispatches.

Turn findings into a plan

"synthesize all the findings into a modernization brief"

Triggers befund-transform-brief — synthesizes stage-map, arch-health, and every other domain summary into a phased, ranked, read-only transformation plan.

Execute one authorized phase

"execute phase 3 from the modernization brief"

Triggers befund-transform-execute — applies exactly one human-authorized phase, gated behind transform.mode: execute, a clean tree, and every Open Question resolved.

Audit UI accessibility

"check our components for accessibility issues and hardcoded design values"

Triggers befund-ui-audit — statically audits JSX/TSX, Vue/Svelte, HTML, and CSS/SCSS for accessibility and design-token problems, never running or rendering the app.

cli-scaffold

plugins/cli-scaffold/README.md — 5 prompts.

Use the slash command directly

/cli-scaffold rust called myapp

The slash command itself — skips straight to generation for a named language and app name.

Ask in plain language

"scaffold a Python CLI named foo that fetches weather data"

Triggers scaffold-cli (interpreted paradigm) — natural-language equivalent of the slash command: resolves the language, loads the doctrine, generates, then verifies.

Scaffold a shell CLI

"scaffold a bash CLI called backup-tool"

Triggers scaffold-cli (shell paradigm, cli-scaffold-shell) — same five-pillar doctrine, plus POSIX-sh bashism checks.

Scaffold a compiled-language CLI

"scaffold a CLI in Go called deploy-bot"

Triggers scaffold-cli (compiled paradigm, cli-scaffold-compiled) — produces a lib+binary split with zero CLI-framework imports in the core library, packaging metadata for Go's idiomatic channel, and a --help snapshot test.

An unsupported or ambiguous language is refused, not guessed

"scaffold a CLI in some scripting language, whatever's easiest"

scaffold-cli refuses outright and lists the 12 supported languages rather than picking one for you — ambiguity is never silently resolved.

cupertino

plugins/cupertino/README.md — 16 prompts.

Run the full review

"run the full cupertino review on this feature"

Triggers cupertino-review — runs all eight lifecycle stages end-to-end, backwards-compatibility check through reveal.

Fix an existing dashboard without breaking it

"the KPI tiles overflow sideways on my phone — fix the dashboard, but don't change how it
looks on desktop or in dark mode"

Triggers cupertino-repair — states the objective and what must be preserved, takes a baseline, gets an approved changeset, applies one item at a time under a hook that scopes each edit, and ends with a verdict. See The repair route.

Convene the council

"convene the cupertino council on this design"

Triggers cupertino-council — five-lens review (Reduction, Craft, Hierarchy, Usability, Metaphor), tensions resolved in a fixed precedence order.

Check against the handbook

"check this codebase against our design handbook"

Triggers cupertino-handbook-check — flags drift from an already-drafted handbook rule, with file:line evidence.

Start from the experience, not the tech

"we need a feature that lets users share a project with a client — nothing's decided yet"

Triggers cupertino-backwards — a pre-architecture gate: establishes what experience actually matters before any database, framework, or API gets named. Always runs first; every other lifecycle stage stays locked until it has.

Cut a sprawling portfolio down

"we have twelve pricing tiers and nobody can explain the difference — help us cut"

Triggers cupertino-focus — runs right after cupertino-backwards, reducing shipped and planned variants to the smallest focused set before architecture work commits effort.

Transfigure a boring feature

"nobody uses our export feature, it's just a chore — can we make it delightful?"

Triggers cupertino-elevate — only for a commodity feature already in scope for the current build (error messages, logs, settings, onboarding...); never seeks one out on its own.

Consider replacing your own best thing

"is it time to replace our own flagship feature with something better we'd build today?"

Triggers cupertino-cannibalize — user-invoked only, never automatic; a deliberate post-ship check on whether to cannibalize a currently-successful, load-bearing thing.

Decide build vs. buy for one seam

"should we build our own auth system or just integrate an existing provider?"

Triggers cupertino-integrate — judges one specific, named boundary at a time; never applied as a blanket build-vs-buy policy across a whole system.

Check whether an architecture will age well

"will this API design still make sense in two years, or are we setting up a rewrite?"

Triggers cupertino-longevity — evaluates whether the architecture can evolve incrementally or is quietly committing to a future rewrite; pairs with cupertino-integrate at architecture-decision time.

Spike an uncertain approach

"I'm not sure this library can actually do what we need — let's just build a throwaway spike"

Triggers cupertino-prototype — settles one specific empirical uncertainty by building and running a small experiment, not by debating it further.

Get the "one more thing"

"is there anything else this needs before we ship it?"

Triggers cupertino-reveal — the final ship-time stage: delivers exactly one non-obvious, high-leverage addition, built rather than pitched — never a list.

Redesign the first five minutes

"our onboarding flow feels clunky — help us fix the first-run experience"

Triggers cupertino-unbox — scoped strictly to a new user's first five minutes (install, first-run, onboarding), distinct from cupertino-elevate's ongoing-feel transfiguration.

Draft a durable handbook

"write us a design handbook that captures our actual conventions"

Triggers cupertino-handbook-draft — persists one checkable rule per dimension for a domain (design, code, testing, or docs), honestly labeling scaffolded defaults where no real convention exists yet.

Pull in just the relevant handbook rules

"what does our handbook say that's relevant to this task?"

Triggers cupertino-handbook-apply — surfaces only the constraints and exceptions relevant to the upcoming task, not the whole document.

Apply the mechanical handbook fixes

"fix the mechanical findings from the last handbook check"

Triggers cupertino-handbook-fix — only after fix mode is explicitly enabled for a domain; never touches a mechanical:false finding, and never infers consent from a check report alone.

lehre

plugins/lehre/README.md — 5 prompts.

Start a new project so it cannot drift

"I'm starting a CLI that ingests CSV from three vendors and writes Parquet. Set it up properly — I don't want the usual mess where everything imports everything."

Triggers lehre-preflight: reports blank page versus existing tree, what doctrine the repository already declares, and what lehre can and cannot enforce here — the automatic first step of any lehre pipeline, which then hands a greenfield repo to lehre-decompose.

Establish and enforce a doctrine on an existing repo

"research what rules this codebase should follow for its stack, check them against what we actually do, and make the important ones actually enforced"

Triggers lehre-codify: researches doctrine from external authority plus real repository evidence and writes .lehre/ruleset.json as machine-checkable rules. Every rule cites an authority; a rule nobody can justify is refused.

Find where the code violates its own architecture

"where do we violate our own layering, and which of those are real"

Triggers lehre-gauge: sweeps the tree against .lehre/ruleset.json and reports every violation with file:line, keeping "could not be evaluated" separate from "clean", and records the sweep under .lehre/gauge/.

Make the rules survive without the plugin

"pin these rules into CI so they still hold when nobody's running Claude"

Triggers lehre-pin: emits a CI check that runs the doctrine with no agent in the loop, plus behaviour tests around the code that was changed to conform.

Ask what is currently blocked

"lehre status — what can I build next?"

Triggers lehre-status: which units are validated, blocked or ready, how many rules are in force, and what is denied at write time right now.

matrize

plugins/matrize/README.md — 7 prompts.

Find out what can honestly be extracted here

"before we start: what can matrize actually measure from these references, and what would only be a guess?"

Triggers matrize-preflight: per-phase Ready / Ready-with-gaps / Not-ready, each reference graded for extraction reliability and for rights, and any existing CSS/token footprint already in the repo.

Lift an ad-hoc project into the taxonomy without changing how it looks

"take this project's scattered CSS and name it as a system — same pixels, just organised and justified"

Triggers matrize-retrofit: maps existing declarations onto the taxonomy and proves zero visual diff, rather than redesigning anything.

Measure the references before interpreting them

"read these references and tell me what they actually do — ratios and relations, with a confidence rating per line"

Triggers matrize-decode: Design Cards with source, selector-or-page reference, and a reliability grade; a second agent re-derives each one from the cited source.

Name what recurs, with the failure case

"give every recurring element a name, a purpose, a rule and an anti-rule"

Triggers matrize-name: writes LEXIKON.md, machine-addressable so dolmetsch can read it; design-critic rejects any rule that is really a copy.

See genuinely different directions side by side

"show me four properly different directions for this, not four shades of the same one"

Triggers matrize-spread: divergent idioms in one fixed shell so they stay comparable, each with a bounded specimen zone, plus a forced-choice block.

Turn vague direction into precise terms

"make it airier — and tell me what that means in actual numbers"

Triggers matrize-dolmetsch: translates both ways against LEXIKON.md, and says so plainly when a term is not in the lexicon rather than guessing.

Produce the approval artefact

"emit the sketchbook as a landscape PDF I can put in front of the client"

Triggers matrize-emit: headless Chrome print-to-pdf honouring @page, with the approval block that names the decision-maker and the gate criteria.

nacharbeit

plugins/nacharbeit/README.md — 6 prompts.

See what a review would measure here

"what would nacharbeit check in this repo, and is anything blocking a run?"

Triggers nacharbeit-preflight: units per plugin by kind, which checkers exist, which other guards are live, and whether a fix lock is open.

Lint a plugin against the standard, for free

"lint plugins/lehre against the Anthropic plugin standard — frontmatter, hooks.json, scripts, the README"

Triggers nacharbeit-lint: the sabotage calibration first, then every mechanical rule (nacharbeit_lint.py --count prints how many); findings by rule and file, nothing applied.

Run the calibrated review

"review our plugins against the nacharbeit rubric and give me the backlog by model tier"

Triggers nacharbeit-review: calibration per family, sealed hold-out, two-lens finders, routing simulation, refuter, opus synthesis, and the findings report.

Apply what a model can apply, under the lock

"apply the haiku and sonnet findings from the review, one file at a time, and tell me what's left for me"

Triggers nacharbeit-fix: the lock opens, the guard denies everything outside it, each file is reworked and blind-verified, the opus and human entries are listed for you.

Check that a skill actually fires

"does the documented prompt for zirkel-clarify-scope actually fire it? measure it, don't guess"

Triggers nacharbeit-probe: dry-runs first with a cost estimate, then runs the prompt headless in fresh processes and reports fired, captured (naming the capturing skill), silent, or UNSTABLE — with the model the rate belongs to.

Find out what is waiting on a person

"nacharbeit status — which findings need a human, and is a fix pass still open?"

Triggers nacharbeit-status: the last run, the held entries verbatim, and a stale lock with its release command.

passung

plugins/passung/README.md — 8 prompts.

Check readiness first

"is this area ready for a consistency pass?"

Triggers passung-preflight — read-only readiness report (stack detection, tooling, test-suite baseline, documented-convention inventory, scope check).

Find the divergence

"find the undocumented style/pattern inconsistencies in billing"

Triggers passung-scan — inventories undocumented, non-deprecated divergence per dimension, actively filtering out documented conventions and version-deprecated idioms.

See it as a matrix

"show me the consistency matrix for billing"

Triggers passung-map — renders the scan as a module × dimension heatmap (matrix.json + an interactive CONSISTENCY_MATRIX.html).

Derive the canon

"decide which pattern should be the canonical one, with provenance"

Triggers passung-canonize — weighs frequency, git-history maturity, and adoption recency per dimension, tagging each pick documented / derived-majority / synthesized-new / needs-human-decision rather than forcing a tie.

Get the approval-ready plan

"write up the alignment brief for billing so I can approve it"

Triggers passung-brief — synthesizes discovery into a phased, dependency-first plan with worked before/after examples; enters plan mode as a human approval gate.

Apply it

"align billing to the approved error-handling-style canon"

Triggers passung-align — applies the canon in place, one pilot module first, then the rest in dependency-aware escalating batches behind a circuit breaker.

Prove nothing broke

"verify the error-handling-style alignment on billing"

Triggers passung-verify — test-suite equivalence (or structural-diff fallback) plus a docs re-sync check, independently re-derived by a second adversarial pass.

Check progress

"where does the billing consistency pass stand?"

Triggers passung-status — read-only artifact inventory, staleness flags, and the single most useful next command.

spur

plugins/spur/README.md — 3 prompts.

Trace a pipeline for a reviewer

"a reviewer wants to know how each figure in the paper was produced — trace the pipeline and show me which step wrote what"

Runs the pipeline once under the tracer and points at spur-report.html, leading with the chain verdict and any broken or unverified input.

Check that the steps really chain

"does the summary step actually read the file the cleaning step wrote, or did something touch it in between?"

Answers from the hash chain: verified, or the broken link with the untraced step that ran between producer and consumer.

Export provenance

"give me W3C PROV for one run of make pipeline"

Traces the run and hands over prov.json, which claims only what was observed.

takt

plugins/takt/README.md — 2 prompts.

Declare the beats for a repository

"set up takt so UI code can't be written before the design council has run"

Writes a .claude/takt.local.md beat with the UI globs and a require marker, after which the hook refuses a matching edit until that marker exists.

Understand a refusal

"takt just blocked my edit — what beat am I running ahead of?"

The denial names the beat id, the reason, and the missing marker; the escape hatch is TAKT_DISABLE_GUARD=1 when the order genuinely does not apply.

zeugnis

plugins/zeugnis/README.md — 9 prompts.

Check for hallucinated dependencies

"check if any of our dependencies are hallucinated"

Triggers zeugnis-dependency-audit — flags package names that don't exist in the real registry, independently re-verified before being reported.

Check test strength

"would our tests actually catch a bug here?"

Triggers zeugnis-assertion-audit — mutation-testing pass checking whether tests assert anything meaningful, not just execute the code.

Kill the survivors with a real mutation tool

"run mutmut on src/shop/pricing.py and write the tests that kill what survives"

Triggers zeugnis-mutation-harden — runs the real tool on a fresh git archive copy as a background script, proves every new test by applying its mutant, and reports the score per module before and after, with untested mutants, equivalents and unreached survivors listed apart.

Run the full cycle

"run the zeugnis cycle on this repo"

Triggers zeugnis-cycle — bounded self-optimization loop: re-runs all four audits pass by pass, optionally applying fixes, until convergence.

Check status

"where does zeugnis stand on this repo"

Triggers zeugnis-status — read-only dashboard: what's run, what's stale, what to run next.

Check for contract drift

"check if our type signatures and docstrings still match how the code is actually called"

Triggers zeugnis-contract-drift — compares type hints, docstrings, and API/OpenAPI/GraphQL schemas against real call-site or handler usage, independently re-verified by default.

Audit the plugin's own agent design

"is our own agent design safe — any unbounded retries or missing escalation paths?"

Triggers zeugnis-agentic-reliability — audits this repo's own skill/agent/workflow definitions for unbounded retry loops, unwired Find/Verify phases, and excessive tool grants.

Quick pre-commit check

"is this diff okay to commit?"

Triggers zeugnis-code-change — runs only the domains whose file patterns match what actually changed, and always produces an advisory verdict that never blocks the commit.

Check readiness first

"is zeugnis set up correctly in this repo?"

Triggers zeugnis-preflight — five independent readiness checks, one verdict per domain skill, before any audit actually runs.

zirkel

plugins/zirkel/README.md — 14 prompts.

Run the full pipeline

"help me think through this, it's complex and I'm not sure of the right approach"

Triggers zirkel-solve — runs the full Clarify → Explore → Decompose → Execute → Revise pipeline.

Explore before committing

"before we commit to an approach, explore a few different ones"

Triggers zirkel-explore-branches — proposes and scores multiple viable approaches instead of anchoring on the first.

Clarify a fuzzy scope

"add caching to the reporting pipeline — the scope is fuzzy, help me pin it down before anything gets built"

Triggers zirkel-clarify-scope — surfaces ambiguous phrasing and unstated success criteria before any work starts.

Break a problem into stages

"break this into steps — what depends on what"

Triggers zirkel-decompose-chain — splits the problem into a 2-5 stage pipeline with explicit input/output contracts per stage, and derives which stages can run in parallel from the dependency graph.

Score and fix a draft

"score this draft against these criteria and fix what's weak"

Triggers zirkel-draft-revise — rates 1-5 against each criterion, revises only what falls at or below threshold, and reports exactly what changed (capped at 2 revision cycles).

Ground every claim

"don't make this up — ground every claim in the actual code or docs"

Triggers zirkel-ground-evidence — requires a file:line, URL, or explicitly-flagged prior knowledge behind every factual claim, and refuses to assert anything unverified.

Investigate step by step

"I don't know where the problem is — go find it"

Triggers zirkel-investigate-dynamically — runs a Reasoning/Action/Observation loop where each observation decides the next step, for cases where the sequence of actions can't be planned upfront.

Trace a multi-hop chain

"trace how A affects D through the whole dependency chain"

Triggers zirkel-map-relationships — extracts indexed relationship triples and traverses them hop by hop, citing the triple index at every hop.

Combine the best of two approaches

"the winner's good, but can we fold in what I liked from the runner-up?"

Triggers zirkel-negotiate-tradeoffs — synthesizes a hybrid from 2-3 already-scored branches, but only presents it if it actually beats every source branch on at least one axis.

Tune a reusable prompt

"find the best wording for this system prompt — I have test cases"

Triggers zirkel-optimize-instruction — generates one candidate per APE framing, scores each against your real test cases, and critiques the winner. Needs representative test cases; not for one-off prompts.

Guard against a silent reasoning error

"walk through this calculation carefully, I can't afford a wrong assumption here"

Triggers zirkel-reason-verify — climbs a 4-rung ladder (zero-shot → Chain-of-Thought → self-consistency → PAL) matched to the actual failure-mode risk, applying Multimodal-CoT first if there's an image or diagram involved.

Anchor a fuzzy output format

"I can't describe the format, but here's an example — make it look like this"

Triggers zirkel-calibrate-format — anchors the target shape to 2-5 concrete input/output examples instead of more prose, enforcing at least one near-boundary example so the set actually pins the decision.

Write up a finished run

"summarize what we just did for the PR"

Triggers zirkel-summarize-trace — produces a fixed 7-section record (asked, assumed, weighed, run, produced, revised, not done) after a zirkel-solve pipeline finishes.

Check one blocking assumption

"before we rely on this, verify it's actually true"

Triggers zirkel-verify-assumptions — checks exactly one named assumption against real evidence in at most 3 steps; for more than one uncertainty, invoke it once per uncertainty.