@r1z4x/tezgah 1.4.0 → 1.5.0

package/CHANGELOG.md

@@ -6,6 +6,75 @@ adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
 
+## [1.5.0] - 2026-10-09
+
+### Changed
+
+- **A plan gets one review, at most two rounds.** The review reads the plan's
+  whole diff once, in its verification phase. Round one spawns its reviewers in
+  one message, one per dimension, or one reviewer for a diff under 300 lines.
+  Only a confirmed critical or major finding opens round two. Round two reads
+  the fix's delta. A minor finding goes on the fix-later list. `tezgah-task review`
+  refuses a third round. What is left after round two goes to the user. The
+  reviewer agent, the contract and plan-sync now state this one rule. Before,
+  the reviewer looped until a round confirmed nothing.
+- **One Acceptance rule.** A plan enters a writing phase only when each
+  Acceptance item names its command or says `unverifiable` and why. Before, one
+  command-bearing item let the move through. `render_table --acceptance
+  --strict` then refused the same plan. Both now read one predicate,
+  `tezgah_task.unproven`, and the refusal names each item's line.
+- **Typed decisions take any Jev carrier.** Taste's `learn`, `label`,
+  `calibrate`, `gate` and `measure --typed` require the Jev model, not
+  TypeSafe's address. So do taste's background start and replay's
+  `--label-model`. OpenRouter System One, Cloudflare Workers AI or a
+  compatible endpoint counts the same. Old `typesafe` rows keep counting.
+  `learn`'s report key `typesafe` is now `jev`. Replay's `--provider typesafe`
+  is now `--provider jev`, and the old name still works. The triage's no-judge
+  message names every carrier, the selection knob and the session CLIs.
+- **The fan-out rule arms on the lists the owner writes.** Items written
+  `1 - ...`, `1- `, `1:`, `a)` or `+` now arm it. An inline `1. ... 2. ...`
+  arms it, and so does "subagentlerle". Three files named as one list arm it
+  too, and so do "First, ... Second, ..." and three imperative clauses. A later
+  list in the same session gets a line that names the action: count the items,
+  one subagent per item in one message. The rule covers every phase: a plan's
+  tasks, its acceptance commands and a survey's sources fan out too. The clause
+  that let a list of small items run one by one is gone.
+
+### Added
+
+- **Plan order and progress in `tezgah-task status`.** A plan can name the
+  plans it waits on with `after:`. `status` prints each open plan's ticked
+  Acceptance boxes and what it still waits on. A `parallel:` line names the
+  ready plans whose `allowed_paths:` share no prefix. Those can run at once.
+  An open plan whose `status:` is not open or blocked is a `FAIL` line, and so
+  is an `after:` id no plan carries. `--json` adds `open` and `parallel`.
+- **The judge asks opencode, Cursor and Codex sessions too.** The judgement
+  seam's session CLI was omp or claude only. It now also runs `opencode run`,
+  `cursor-agent -p` and `codex exec` headless when their host's marker is set
+  (`OPENCODE`, `CURSOR_AGENT`/`CURSOR_VERSION`, `CODEX_THREAD_ID`).
+  `TEZGAH_JUDGE_CLI`, else `judge_cli` in `config.json`, picks one of the five
+  by name. A picked CLI that is not installed means no session CLI.
+- **Jev through any carrier.** The judge reaches Jev through TypeSafe,
+  OpenRouter, Cloudflare Workers AI or a System One-compatible URL
+  (`JEV_API_BASE_URL`, `JEV_API_KEY`).
+  `TEZGAH_JEV_PROVIDER`, `JEV_PROVIDER` or config.json `jev` picks the carrier,
+  and `tezgah-setup --jev <value>` writes the config key. `auto` asks every
+  carrier that resolves. A named carrier without its credential gets no
+  request, and no other carrier stands in. `tezgah-status --judge` prints the
+  choice and its carriers.
+- **The omp login is a TypeSafe key.** With no `TYPESAFE_API_KEY` and no key
+  file, the seam reads the active omp login, read-only.
+- **Clef and Clef-flash as typed judges.** Cloudflare's own decision models
+  answer the System One API on Workers AI with the Cloudflare token and account
+  id. `--jev clef` or `--jev clef-flash` picks one, and `auto` asks them after
+  the Jev carriers. A typed decision counts them like Jev. Cost rows now price
+  the carrier that answered: $0.24 per 1M input for Clef, $0.09 for Clef-flash.
+
+### Fixed
+
+- **A spent key stops costing a request.** OpenRouter answers 403 to a key
+  past its limit. A 403 now marks a provider down for five minutes, like a 401.
+
 ## [1.4.0] - 2026-10-08
 
 ### Changed
@@ -864,7 +933,8 @@ adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
   the copy could not find `hooks/` and died on import. It now links into the
   installed tree, and also installs the command as `tezgah`.
 
-[Unreleased]: https://github.com/r1z4x/tezgah/compare/v1.4.0...HEAD
+[Unreleased]: https://github.com/r1z4x/tezgah/compare/v1.5.0...HEAD
+[1.5.0]: https://github.com/r1z4x/tezgah/releases/tag/v1.5.0
 [1.4.0]: https://github.com/r1z4x/tezgah/releases/tag/v1.4.0
 [1.3.0]: https://github.com/r1z4x/tezgah/releases/tag/v1.3.0
 [1.2.0]: https://github.com/r1z4x/tezgah/releases/tag/v1.2.0

package/agents/tezgah-reviewer.md

@@ -3,7 +3,9 @@ name: tezgah-reviewer
 description: >
   Adversarial, read-only review of a diff, branch or PR: derives the blast
   radius, checks correctness, contract, security, tests and performance, and
-  classifies every finding confirmed/refuted/unverified.
+  classifies every finding confirmed/refuted/unverified. One review per
+  plan, at most two rounds; spawn one per dimension in one message for a
+  large diff.
 model: opus
 effort: high
 readonly: true
@@ -56,15 +58,22 @@ is lowered only by evidence: a check you could not complete never
 downgrades a confirmed finding - keep its severity and mark it
 provisional. Disclose the order you read the files in.
 
-Scope and budget. Every round that confirms a defect is followed by a
-round over that fix's delta; the review ends when a round confirms none.
-A later round reads only the delta since the sha the previous round
-recorded (`tezgah-task review` prints it): re-reading the whole diff
-re-reports what was already triaged. Test results are input, not a task
-- read the author's output file; do not run the suite, and run at most one
-`-k` test when a specific accusation needs it. The same defect family
-confirmed three times is a sign the design needs a pivot, not another
-patch.
+Scope and budget. One review per plan, over its whole diff in the
+verification phase; at most two rounds - only a confirmed critical or
+major finding opens round two, a minor or suggestion one is recorded
+fix-later, and after round two what is left goes to the user or is
+recorded fix-later, never a third round. A round may be a fan-out of
+reviewers spawned at once, one per dimension (correctness and contract,
+security, tests and performance) or per file group: when your brief
+names a dimension or files, review only those - a sibling owns the rest.
+Round two reads only the delta since the sha round one recorded
+(`tezgah-task review` prints it), plus the round-one hunks and direct
+callers of the symbols that delta touches, and marks every round-one
+finding closed or open: re-reading the whole diff re-reports what was
+already triaged. Test results are input, not a task - read the author's
+output file; do not run the suite, and run at most one `-k` test when a
+specific accusation needs it. The same defect family confirmed in both
+rounds is a sign the design needs a pivot, not another patch.
 
 You may use: the codegraph MCP tools, read, grep and glob. Read-only:
 no writes, no edits, no shell.

package/bin/tezgah-docs

@@ -24,7 +24,7 @@ every word is part of the query.
 
 Matching is word-based and case-insensitive against an entry's title, its
 questions, its sources and its path; every word must match, so a second word
-narrows. A query that matches nothing is the last resort of one TypeSafe Choice
+narrows. A query that matches nothing is the last resort of one judge-seam Choice
 question over the pages themselves; it answers `none` for a query no page
 covers. When that question gives no judgement - unavailable (`docs-judge-off`,
 the seam's `judge-off`, no credential) or a call that failed or came back
@@ -106,7 +106,7 @@ RUN = re.compile(r"((?:`[A-Za-z_][A-Za-z0-9_]*(?:\(\))?`\s*[/,]?\s*){1,5})$")
 CITE = re.compile(r"`([\w.-]+(?:/[\w.-]+)+|[\w-]+\.\w+):(\d+)(?:-(\d+))?`"
                   r"|`(:(\d+)(?:-(\d+))?)`")
 # The symbol written after the citation instead of before it, the way a table
-# cell reads: `hooks/tezgah_policy.py:667-928` (`CORE`).
+# cell reads: `hooks/tezgah_policy.py:678-946` (`CORE`).
 AFTER = re.compile(r"\s*\(`([A-Za-z_][A-Za-z0-9_]*)(?:\(\))?`\)")
 # Any `path:line`, backticked or not: what CITE does not match of these (a
 # bare token, a comma list `x.py:12,40`) is counted as unjudged, so a citation
@@ -1036,7 +1036,7 @@ def record(result):
 
 
 def judge_pick(query):
-    """(judged, page): whether a TypeSafe Choice question came back with one of
+    """(judged, page): whether a judge-seam Choice question came back with one of
     its options, and the page it named (None for `none`).
 
     The last resort for a query the index could not place: a word the index does

package/bin/tezgah-route

@@ -12,8 +12,11 @@ A brief naming stored data, a migration, credentials, the gate or security goes
 tezgah-frontier by rule; otherwise Jev picks the tier (one Choice, ~650 input
 tokens, ~0.4 s); with no key or `judge-off`, `--phase`
 (explore|code|mechanical|plan|review|research) picks it from the static table, and
-with neither the middle tier is used. The brief is sent to api.typesafe.ai (or the
-OpenRouter fallback) - write it in English, the language the judge reads best.
+with neither the middle tier is used. The brief is sent to the judge seam's
+provider - the session's own CLI (omp, claude, opencode, cursor, codex) or the Jev
+model through TypeSafe, OpenRouter System One, Cloudflare Workers AI or a
+compatible endpoint (TEZGAH_JEV_PROVIDER picks one), else the OpenRouter chat
+fallback - so write it in English, the language the judge reads best.
 
 Every routed call writes one `route` row to the session's ledger (TEZGAH_SESSION):
 tier, agent, what set the tier (`via`: rule|jev|phase|default), the static

package/bin/tezgah-setup

@@ -884,6 +884,22 @@ def save_features(ids):
     return True
 
 
+def set_jev(value):
+    """Persist `value` as config.json["jev"] - this key's only writer - and print
+    the carriers it resolves to now. An unchanged value writes nothing, like
+    `save_features`; a config that does not parse is refused, not replaced."""
+    import tezgah_judge
+    cfg = read_config(tp.CONFIG, {})
+    if cfg is None:
+        sys.stderr.write("tezgah-setup: %s is not valid JSON; jev not set\n" % tp.CONFIG)
+        return 1
+    if cfg.get("jev") != value:
+        cfg["jev"] = value
+        write_json(tp.CONFIG, cfg)
+    print("%s %s  %s" % (OK, tp.CONFIG, tezgah_judge.jev_summary()))
+    return 0
+
+
 def app_servers(selected=None):
     """The app-analysis MCP servers to wire this run (shared spec)."""
     return tezgah_apps.servers(selection() if selected is None else selected)
@@ -4767,7 +4783,7 @@ def host_checks_omp():
          tp.have_typesafe_key()),
         # One row per channel: the two disagree in both directions - a key file
         # alone serves the seam, an omp login-store record alone serves omp.
-        ("judgement seam key resolvable (env or key file)",
+        ("judgement seam key resolvable (session CLI, Jev carrier or OpenRouter)",
          tp.have_judge_key()),
         ("status line answers", omp_hook_answers()), ("tier models in task.agentModelOverrides and modelRoles.plan/slow", tier_models_current()),
     ]
@@ -5679,6 +5695,11 @@ def main(argv):
                     help="with --install: the language replies are asked for and "
                          "the Stop rule checks (config.json `reply_lang`; `tr` "
                          "when unset, `any` checks none)")
+    ap.add_argument("--jev", choices=tp.JEV_CHOICES,
+                    help="the carrier the judgement seam reaches the Jev model "
+                         "through (config.json `jev`; `auto` tries every one "
+                         "that resolves); TEZGAH_JEV_PROVIDER and JEV_PROVIDER "
+                         "still win over it")
     # `--version` is argparse's print-and-exit action, so `--upgrade --version V`
     # would print the current version, exit 0 and move nothing at all - the
     # "reads as done, did nothing" shape this repo hunts. Refused by name here,
@@ -5731,6 +5752,8 @@ def main(argv):
     if args.features:
         features_report()
         return 0
+    if args.jev:
+        return set_jev(args.jev)
     if args.refresh:
         paths = refresh_contract()
         for path in paths:

package/bin/tezgah-status

@@ -298,7 +298,9 @@ def main():
         last = tj.last_use()
         if "--json" in flags:
             print(json.dumps(last, sort_keys=True))
-        elif not last:
+            return 0
+        print(tj.jev_summary())
+        if not last:
             print("judge: no judgement recorded")
         elif last.get("provider"):
             print("judge: %s answered with %s/%s (fallback=%s)%s" % (

package/bin/tezgah-task

@@ -5,7 +5,7 @@
   tezgah-task phase P [--any-path]                            change the active task's phase
   tezgah-task allow GLOB ... | --any-path                     replace the allowlist
   tezgah-task stop                                            deactivate (clear phase)
-  tezgah-task status [--json]                                 the active task, or "no active task"
+  tezgah-task status [--json]                                 the active task, then every open plan: progress, what it waits on, what can run at once
   tezgah-task review <NNN|path> <reviewer> approve|changes    record a fresh review's verdict
   tezgah-task close <NNN|path> done|discarded                 move a plan to .tezgah/plans/done
 
@@ -22,21 +22,27 @@ creates the plan, and `start` without `--allow` keeps it. A writing phase with
 no allowlist is refused unless `--any-path` says so explicitly, and the record
 keeps where its scope came from (`allowed_from:`), which `status` prints.
 
-`review` and `close` are the session's: the verification phase asks for a
-fresh reviewer's read of the diff, `review` records its verdict as
+`review` and `close` are the session's: the verification phase asks for one
+review of the plan's whole diff, `review` records its verdict as
 `review: <reviewer> <verdict> <date>` together with `reviewed_sha:` (the
 project's HEAD it read) and `review_round:`, so the next round reads only
-`git diff <reviewed_sha>..HEAD` and the two-round budget is countable; `close
-NNN done` refuses a plan whose review is missing or not `approve`. `close`
-refuses the active task - that one is the user's to stop first.
+`git diff <reviewed_sha>..HEAD`, and refuses a third round: the budget is two
+rounds per plan; `close NNN done` refuses a plan whose review is missing or not
+`approve`. `close` refuses the active task - that one is the user's to stop first.
 
 Two things the plan owes are asked here, at the only moment they can still be
 fixed - the phase move - because the record is the user's and the refusal is
-this CLI's: a writing phase needs at least one Acceptance item that names the
-command proving it (or says `unverifiable` and why), since the report CI runs
-afterwards reads the same items and refuses the same plan too late; and
-`implementation` needs the plan's spike answered, so the build starts on
-evidence rather than on the guess the spike exists to retire.
+this CLI's: a writing phase needs every Acceptance item to name the command
+proving it (or say `unverifiable` and why), since the report CI runs afterwards
+refuses an open plan on any one item that does neither, through the same
+predicate (`tezgah_task.unproven`); and `implementation` needs the plan's spike
+answered, so the build starts on evidence rather than on the guess the spike
+exists to retire.
+
+`status` lists every open plan after the active task: its Acceptance boxes
+ticked, the plans its `after:` still waits on, and - on a `parallel:` line - the
+ready plans whose `allowed_paths:` share no prefix, which can run at once. A
+status outside open|blocked, or an `after:` id no plan carries, is a `FAIL` line.
 
 Entering `implementation` also records where the risky work returns to: a
 `checkpoint:` field holding the pre-work commit's sha, or `pending <sha>` while
@@ -139,6 +145,14 @@ def write_fields(path, **fields):
 
 ANY_PATH = "--any-path"
 VERDICTS = ("approve", "changes")
+# The review budget, enforced here and nowhere else: `review` refuses a third
+# round, and every text that states the rule (the reviewer agent, the contract,
+# plan-sync) says the same two rounds.
+REVIEW_ROUNDS = 2
+# Under this many changed lines one reviewer reads every dimension; at or above
+# it the round fans out. ponytail: a line count, not a risk model - a small diff
+# that touches a trust boundary is the brief's to route to security.
+SMALL_DIFF = 300
 
 
 def allow_source(text):
@@ -279,13 +293,14 @@ def phase_problems(phase, text, path):
         items = tt.acceptance_gap(text)
         if items:
             out.append(
-                "%s cannot enter %s: all %d of its Acceptance items name no "
-                "command and none declares `unverifiable` (read by "
-                "hooks/tezgah_task.py:acceptance_items), so the work has no check "
-                "to be held to. Give at least one item the command that proves "
+                "%s cannot enter %s: %d of its %d Acceptance items name no "
+                "command and declare no `unverifiable` (read by "
+                "hooks/tezgah_task.py:acceptance_items; at %s), so that work has "
+                "no check to be held to. Give each one the command that proves "
                 "it, or `unverifiable` and why; "
-                "`tezgah-render-table --acceptance` reports the same items"
-                % (path, phase, len(items)))
+                "`tezgah-render-table --acceptance --strict` refuses the same items"
+                % (path, phase, len(items), len(tt.acceptance_items(text)),
+                   ", ".join("%s:%d" % (path, i["line"]) for i in items)))
     if phase == "implementation" and tt.spike_unanswered(text):
         out.append(
             "%s cannot enter implementation: its spike is unanswered - `spike:` "
@@ -295,12 +310,23 @@ def phase_problems(phase, text, path):
     return out
 
 
+def changed_lines(root, base):
+    """Lines `git diff <base>..HEAD` adds and removes, or None when git cannot
+    say (no base, not a repository)."""
+    stat = git_out(root, "diff", "--shortstat", base + "..HEAD") \
+        if base != "<base>" else None
+    if stat is None:
+        return None
+    return sum(int(n) for n in re.findall(r"(\d+) (?:insertion|deletion)", stat))
+
+
 def verification_steps(text, path):
     """What the verification phase requires before the plan is done: the plan's
-    own acceptance commands run once on the final tree, unpiped, and a fresh
-    reviewer's read of the diff, recorded with `review` - `close NNN done` refuses
-    without it. A round after the first reads only the delta since the sha the
-    last `review` recorded, and the review budget is two rounds."""
+    own acceptance commands run once on the final tree, unpiped, and ONE review
+    of the plan's whole diff, recorded with `review` - `close NNN done` refuses
+    without an approve. Round one fans out one reviewer per dimension, round two
+    reads only the delta since the sha round one recorded, and REVIEW_ROUNDS is
+    the budget `review` enforces."""
     fields = tt.frontmatter(text)
     ident = fields.get("id") or os.path.basename(path).split("-")[0]
     # every item, not only the ones the command reader recognises: `pnpm test`
@@ -311,27 +337,51 @@ def verification_steps(text, path):
              for i in tt.acceptance_items(text)]
     # the project, not the private repository `.tezgah` may hold
     root = os.path.realpath(os.path.join(os.path.dirname(path), "..", "..", ".."))
-    reviewed = fields.get("reviewed_sha") or ""
+    reviewed = fields.get("reviewed_sha") or "(no commit)"
     prior = fields.get("review_round") or ""
     rounds = int(prior) if prior.isdigit() else 0
     print("verification - required before this plan is done:")
     print("  1. prove the acceptance items ONCE, on the final tree - not again per "
           "review round - every command run unpiped "
-          "(`cmd > /tmp/check.log 2>&1`, then read the file):")
+          "(`cmd > /tmp/check.log 2>&1`, then read the file); items that share "
+          "no state go out as tool calls in ONE message, one suite run at a time:")
     for item in items or ["(the plan has no Acceptance items)"]:
         print("     - %s" % item)
     if os.path.isfile(os.path.join(root, "tests", "impacted.py")):
         print("     the one full run here is `python3 tests/impacted.py --all`")
-    if reviewed:
-        print("  2. review round %d: a fresh tezgah-reviewer reads only the delta "
-              "`git diff %s..HEAD` and the test output above; it does not re-run "
-              "the suite" % (rounds + 1, reviewed))
-        if rounds >= 2:
-            print("     the 2-round budget is spent: triage what is left as block "
-                  "(back to the user) or fix-later (recorded), never a third loop")
+    if rounds and review_verdict(text) == "approve":
+        print("  2. the review approved in round %d at %s: no further round"
+              % (rounds, reviewed))
+        print("  3. `tezgah-task close %s done` once the work lands" % ident)
+        return
+    if rounds >= REVIEW_ROUNDS:
+        print("  2. the %d-round budget is spent: `tezgah-task review` refuses a "
+              "third round. A critical or major finding still confirmed goes to "
+              "the user (block); a minor or suggestion one is recorded fix-later "
+              "under the plan's ## State" % REVIEW_ROUNDS)
+        return
+    if rounds:
+        print("  2. review round 2 (the last): each confirmed critical or major "
+              "finding is fixed with a regression test that failed first; one "
+              "fresh tezgah-reviewer reads only the delta `git diff %s..HEAD`, the "
+              "round-1 hunks and direct callers of the symbols it touches, and the "
+              "test output above, and marks every round-1 finding closed or open; "
+              "it does not re-run the suite" % reviewed)
     else:
-        print("  2. a fresh reviewer - the host's tezgah-reviewer subagent - "
-              "reads `git diff %s..HEAD` and the test output above" % diff_base(root))
+        base = diff_base(root)
+        size = changed_lines(root, base)
+        print("  2. one review of the whole plan, at most %d rounds: spawn fresh "
+              "tezgah-reviewer subagents in ONE message, each owning one dimension "
+              "- correctness and contract, security, tests and performance - or one "
+              "file group of a large diff, over `git diff %s..HEAD` and the test "
+              "output above, then merge their findings into one verdict. Under %d "
+              "changed lines one reviewer reads every dimension (this diff: %s), "
+              "unless the diff touches auth, secrets or a gate, which keeps a "
+              "security reviewer" % (REVIEW_ROUNDS, base, SMALL_DIFF,
+                                     "unknown" if size is None else size))
+        print("     only a confirmed critical or major finding is `changes` and "
+              "opens round 2; a minor or suggestion one is recorded fix-later "
+              "under ## State and the verdict is `approve`")
     print("  3. record its verdict: `tezgah-task review %s <reviewer> approve|changes`"
           " (records the reviewed sha);"
           " `tezgah-task close %s done` refuses without an approve" % (ident, ident))
@@ -495,6 +545,16 @@ def review_verdict(text):
     return parts[1] if len(parts) >= 2 and parts[1] in VERDICTS else None
 
 
+def budget_spent(path, ident):
+    """The refusal once REVIEW_ROUNDS rounds are recorded: what is left belongs
+    to the user, never to a third round."""
+    return ("%s has spent its %d-round review budget: never a third round. A "
+            "critical or major finding still confirmed goes to the user, who "
+            "decides (block); a minor or suggestion one is recorded fix-later "
+            "under the plan's ## State; `tezgah-task close %s discarded` needs no "
+            "review" % (path, REVIEW_ROUNDS, ident))
+
+
 def cmd_review(args):
     if len(args) != 3 or args[2] not in VERDICTS:
         return misuse("review takes <NNN|path> <reviewer> %s" % "|".join(VERDICTS))
@@ -503,6 +563,8 @@ def cmd_review(args):
         return problems([problem])
     fields = tt.frontmatter(read(path))
     prior = fields.get("review_round") or ""
+    if prior.isdigit() and int(prior) >= REVIEW_ROUNDS:
+        return problems([budget_spent(path, os.path.basename(path).split("-")[0])])
     # the project's HEAD, never the private `.tezgah` repository's: the next
     # round's delta is `git diff <this>..HEAD` over the project
     root = os.path.realpath(os.path.join(os.path.dirname(path), "..", "..", ".."))
@@ -535,6 +597,9 @@ def cmd_close(args):
         return problems(["%s is the active task: the user stops it first "
                          "(`tezgah-task stop`)" % path])
     if args[1] == "done" and review_verdict(text) != "approve":
+        prior = tt.frontmatter(text).get("review_round") or ""
+        if prior.isdigit() and int(prior) >= REVIEW_ROUNDS:
+            return problems([budget_spent(path, ident)])
         return problems(["%s records no approving review: a fresh reviewer reads "
                          "the diff, then `tezgah-task review %s <reviewer> approve`"
                          % (path, ident)])
@@ -561,22 +626,50 @@ def cmd_status(args):
     bad = []
     for path in plans(root):
         fields = tt.frontmatter(read(path))
+        ident = fields.get("id") or os.path.basename(path).split("-")[0]
         phase = fields.get("phase") or ""
         if phase and phase not in tt.TASK_PHASES:
-            bad.append({"id": fields.get("id") or os.path.basename(path).split("-")[0],
-                        "phase": phase, "path": path})
+            bad.append({"id": ident, "phase": phase, "path": path,
+                        "problem": "phase %r is not one of %s, so the plan is ignored (%s)"
+                        % (phase, ", ".join(tt.TASK_PHASES), path)})
+        status = fields.get("status") or ""
+        if status not in tt.OPEN_STATUSES:
+            bad.append({"id": ident, "path": path,
+                        "problem": "status %r is not one of %s, which is what a plan "
+                        "under .tezgah/plans/open carries (%s)"
+                        % (status, ", ".join(tt.OPEN_STATUSES), path)})
+    rows = tt.queue(root)
+    for row in rows:
+        for ident, state in row["after"]:
+            if state == "missing":
+                bad.append({"id": row["id"], "path": row["path"],
+                            "problem": "`after: %s` names no plan under .tezgah/plans "
+                            "(%s)" % (ident, row["path"])})
+    together = tt.parallel(rows)
     if task:
         task["allowed_from"] = allow_source(read(task["path"]))[1]
     if as_json:
-        print(json.dumps({"active": task, "malformed": bad}, indent=2))
+        print(json.dumps({"active": task, "malformed": bad, "open": rows,
+                          "parallel": together}, indent=2))
     else:
         if task:
             show(task["path"])
         else:
             print("no active task")
+        if rows:
+            print("open plans: %d, %d ready" % (len(rows), sum(r["ready"] for r in rows)))
+        for row in rows:
+            waits = ["%s (%s)" % (ident, state) for ident, state in row["after"]
+                     if state != "done"]
+            print("  %s %s, acceptance %d/%d checked, %s" % (
+                row["id"], row["status"] or "(no status)", row["checked"], row["items"],
+                "ready" if row["ready"] else
+                "waits on %s" % ", ".join(waits) if waits else row["status"]))
+        if together:
+            print("parallel: %s - ready, and no two share an allowed_paths prefix"
+                  % ", ".join(together))
         for row in bad:
-            print("FAIL %s: phase %r is not one of %s, so the plan is ignored (%s)"
-                  % (row["id"], row["phase"], ", ".join(tt.TASK_PHASES), row["path"]))
+            print("FAIL %s: %s" % (row["id"], row["problem"]))
     return 1 if bad else 0