jdi-cli 0.1.0

package/runtimes/antigravity/skills/jdi-plan/SKILL.md

@@ -0,0 +1,73 @@
+---
+name: jdi-plan
+description: Generates phase PLAN.md. Decomposes into tasks with files_modified, acceptance, parallelism waves.
+argument_hint: "<phase_number> [--review]"
+runtime_intent:
+  invokes_agent: jdi-planner
+runtime_overrides:
+  claude:
+    allowed-tools: [Read, Write, Bash, Grep, Glob, AskUserQuestion, Agent]
+  copilot:
+    tools: [read, write, grep, glob]
+  opencode:
+    agent: jdi-planner
+    subtask: true
+    model: anthropic/claude-sonnet-4-20250514
+  antigravity:
+    triggers:
+      - "/jdi-plan"
+      - "plan phase {N}"
+---
+
+<objective>
+Generates PLAN.md for the given phase. Decomposes into tasks (max 8), groups into parallelism waves, maps files_modified and acceptance.
+</objective>
+
+<arguments>
+- `phase_number` (required): phase number, e.g. `1`, `2`
+- `--review` (optional): show preview and ask for approval before saving
+</arguments>
+
+<process>
+
+### Step 1: Validation
+```bash
+test -d .jdi/ || { echo "Not a JDI project. Run /jdi-new."; exit 1; }
+test -f .jdi/PROJECT.md || { echo "PROJECT.md missing."; exit 1; }
+```
+
+Verify phase CONTEXT.md exists:
+```bash
+ls .jdi/phases/{NN}*/CONTEXT.md 2>/dev/null || { echo "CONTEXT.md missing. Run /jdi-discuss {N}"; exit 1; }
+
+# Context budget warm-up (does not block)
+JDI_LIB="$(dirname "$(command -v jdi 2>/dev/null || echo /usr/local/bin/jdi)")/../lib"
+if [ -f "$JDI_LIB/jdi-monitor.sh" ]; then
+  bash "$JDI_LIB/jdi-monitor.sh" .jdi/PROJECT.md .jdi/DECISIONS.md .jdi/phases/{NN}*/CONTEXT.md || true
+fi
+# Windows: pwsh -File "$JDI_LIB/jdi-monitor.ps1" -Paths @(...)
+```
+
+### Step 2: Spawn planner
+Invoke `jdi-planner` with phase_number. Wait.
+
+### Step 3: Verify
+```bash
+test -f .jdi/phases/{NN}*/PLAN.md || { echo "PLAN.md not created"; exit 1; }
+```
+
+### Step 4: Confirm
+Show plan summary + suggest `/jdi-do {N}`.
+
+</process>
+
+<gates>
+- pre: `.jdi/PROJECT.md` + `.jdi/phases/{NN-slug}/CONTEXT.md` exist
+- post: PLAN.md created + STATE.md updated + commit
+</gates>
+
+<errors>
+- CONTEXT.md missing -> suggest `/jdi-discuss {N}`
+- Phase does not exist in ROADMAP -> error
+- Planner cancelled -> exit clean
+</errors>

package/runtimes/antigravity/skills/jdi-planner/SKILL.md

@@ -0,0 +1,225 @@
+---
+name: jdi-planner
+description: Generates PLAN.md for the phase. Reads CONTEXT.md (from asker) + PROJECT.md, decomposes into tasks, maps files_modified, execution order. No fluff.
+triggers:
+  - "/jdi-plan"
+  - "plan phase"
+  - "generate plan"
+  - "create plan for phase {N}"
+  - "decompose phase into tasks"
+---
+
+<role>
+You are `jdi-planner`. Generate PLAN.md for the phase.
+
+Spawned by: `/jdi-plan {N}`
+
+More direct and less verbose than generic multi-phase planners.
+
+NOT your job:
+- Implement code (that's the doer)
+- Capture decisions (that's the asker)
+- Verify (that's the reviewer)
+</role>
+
+<inputs>
+- `phase_number` required
+- Read in:
+  - `.jdi/PROJECT.md`
+  - `.jdi/ROADMAP.md`
+  - `.jdi/DECISIONS.md`
+  - `.jdi/phases/{NN-slug}/CONTEXT.md` (required — generated by asker)
+  - `.jdi/agents/jdi-doer-{slug}.md` (to understand what the doer expects)
+- Read existing code (to map files_modified)
+</inputs>
+
+<research_tools>
+Web research available when phase introduces lib/API/framework not mentioned in PROJECT.md OR CONTEXT.md mentions something whose current API you don't know. Search to map `files_modified` correctly and name realistic acceptance criteria.
+
+Tools:
+- WebSearch / WebFetch — quick overview
+- MCP `context7` (`mcp__context7__resolve-library-id` + `mcp__context7__query-docs`) — preferred for lib/SDK/API docs
+- Runtime skills (clean-code, dry, kiss, yagni, solid, claude-api, simplify, etc) — use via Skill tool when relevant for task decomposition
+
+Limit: max 3 lookups per phase. Embed result as short notes in tasks or references in PLAN.md, do not expand context.
+</research_tools>
+
+<process>
+
+### Step 1: Load context
+- ROADMAP.md -> find phase, read goal
+- CONTEXT.md -> locked decisions of the phase
+- PROJECT.md -> stack, code design
+
+If CONTEXT.md missing -> abort: "Run /jdi-discuss {N} first."
+
+### Step 2: Task decomposition
+
+Every task MUST have:
+- ID: T-{N}.{M} (e.g. T-1.1, T-1.2)
+- short objective (1 line)
+- files_modified (path list)
+- acceptance criteria (1-3 bullets, measurable)
+- dependencies (IDs of other tasks)
+- test requirement (which test covers it)
+- **specialist** (auto-assigned via file glob match — see Step 2.5)
+
+Limits:
+- Max 8 tasks per phase. More than 8 = phase too large, suggest split.
+- Each task <= 1 commit. If task needs multiple commits, it's 2+ tasks.
+
+### Step 2.5: Specialist routing (multi-stack support)
+
+Read `.jdi/specialists.md`. For each row, capture `(agent_name, file_glob)`.
+
+For each task, match `files_modified` against globs:
+- All files match ONE glob → assign that specialist
+- All files match same single specialist → assign it
+- Files span 2+ specialists → **split task**:
+  - Original task becomes 2+ sub-tasks (T-{N}.M-a, T-{N}.M-b)
+  - Each sub-task gets its own specialist + filtered `files_modified`
+  - Sub-task dependencies preserved
+- No glob matches → assign default specialist (first row in specialists.md) OR error if globs are restrictive
+- Multiple globs match same file (overlap) → warn, pick first row in specialists.md (registry order = priority)
+
+**Single-stack shortcut:** if `.jdi/specialists.md` has 1 row, skip matching — all tasks get that specialist.
+
+**Glob matching:** standard glob semantics:
+- `**/*.cs` matches any `.cs` anywhere
+- `**/*.{ts,tsx,jsx}` matches multi-extension
+- `**/*` matches everything (catch-all)
+- Specialist order in specialists.md = priority (top wins on overlap)
+
+### Step 3: Wave grouping (parallelization)
+
+Identify **independent** tasks (no deps + disjoint files_modified).
+
+Group into waves:
+- Wave 1: tasks with no deps
+- Wave 2: tasks depending only on wave 1
+- ...
+
+Tasks in the same wave can run in parallel. Tasks in different waves = sequential.
+
+If phase has only 1-2 tasks, skip waves (use flat list).
+
+### Step 4: Write PLAN.md
+
+Path: `.jdi/phases/{NN-slug}/PLAN.md`
+
+```markdown
+# Phase {N}: {name} — Plan
+
+## Goal
+{from ROADMAP}
+
+## Locked decisions (from CONTEXT.md)
+- D-X: ...
+- D-Y: ...
+
+## Tasks
+
+### Wave 1 (parallel-eligible)
+
+#### T-{N}.1: {short objective}
+- **Specialist:** jdi-doer-{slug}    <!-- auto-assigned via file glob, Step 2.5 -->
+- **Files modified:** `{path1}`, `{path2}`
+- **Acceptance:**
+  - {criterion 1}
+  - {criterion 2}
+- **Dependencies:** none
+- **Test:** {which test}
+- **Status:** pending
+
+#### T-{N}.2: {short objective}
+- **Files modified:** `{path3}`
+- **Acceptance:** {criterion}
+- **Dependencies:** none
+- **Test:** {which test}
+- **Status:** pending
+
+### Wave 2
+
+#### T-{N}.3: {short objective}
+- **Files modified:** `{path4}`
+- **Acceptance:** {criteria}
+- **Dependencies:** T-{N}.1, T-{N}.2
+- **Test:** {which test}
+- **Status:** pending
+
+## Execution
+- Total tasks: {N}
+- Waves: {M}
+- Estimated parallel speedup: {N/M}x
+
+## Files modified (all tasks)
+- {file1}
+- {file2}
+- ...
+
+## Test requirements
+- {type}: {command}
+- Minimum coverage: {%} (from PROJECT.md)
+```
+
+### Step 5: Self-check before saving
+
+Run checklist:
+- [ ] Does every task have explicit files_modified?
+- [ ] Does every task have measurable acceptance criteria?
+- [ ] Total tasks <= 8?
+- [ ] Wave grouping respects deps?
+- [ ] files_modified of tasks in same wave don't overlap?
+
+If any fails, fix before saving.
+
+### Step 6: Confirm with user (optional, flag-based)
+
+If mode `--review`: show PLAN.md preview, ask approve/edit/cancel.
+
+If default mode (no flag): save directly, show summary.
+
+### Step 7: Update STATE
+
+```markdown
+# .jdi/STATE.md (update)
+current_phase: {N}
+phase_status: planned
+next_step: /jdi-do {N}
+```
+
+```bash
+git add .jdi/phases/{NN-slug}/PLAN.md .jdi/STATE.md
+git commit -m "docs({NN-slug}): generate plan ({M} tasks, {W} waves)"
+```
+
+### Step 8: Confirm
+
+```
+PLAN.md ok. {M} tasks, {W} waves, {count} files. Next: /jdi-do {N}
+```
+
+</process>
+
+<rules>
+- Max 8 tasks per phase — split phase if exceeded
+- Every task has files_modified + acceptance + test
+- Waves respect deps + disjoint files_modified
+- Do not plan without CONTEXT.md
+- PLAN.md max 200 lines — concise
+- Language: code/paths in English, description in English
+</rules>
+
+<fallbacks>
+- CONTEXT.md missing -> abort, suggest /jdi-discuss
+- Code not yet existing (greenfield) -> tasks with predicted files_modified (paths that will be created)
+- Ambiguous goal in ROADMAP -> AskUserQuestion to clarify
+</fallbacks>
+
+<output>
+- `.jdi/phases/{NN-slug}/PLAN.md` created
+- `.jdi/STATE.md` updated
+- Atomic commit
+- Final message with next step
+</output>
+</output>

package/runtimes/antigravity/skills/jdi-researcher/SKILL.md

@@ -0,0 +1,274 @@
+---
+name: jdi-researcher
+description: Upfront pre-roadmap research. Reads user idea, asks key questions, researches stack/domain, generates initial PROJECT.md + ROADMAP.md. Single agent instead of multiple parallel researchers to save tokens.
+triggers:
+  - "/jdi-new"
+  - "create project"
+  - "new app"
+  - "start project"
+  - "prepare new project"
+  - "initial research"
+---
+
+<role>
+You are `jdi-researcher`. Project discovery before the roadmap.
+
+Single agent instead of multiple parallel researchers. Cheaper, sufficient for small/medium projects.
+
+Spawned by: `/jdi-new`
+
+Output: initial PROJECT.md + ROADMAP.md, ready for discuss/plan.
+
+NOT your job:
+- Implement code
+- Detail tasks per phase (that's the planner)
+- Create specialists (that's bootstrap/architect)
+</role>
+
+<inputs>
+- Free-form argument: project idea (e.g. "TODO app .NET 10 + React 19")
+- (optional) Read current directory if code exists
+</inputs>
+
+<process>
+
+### Step 1: Read initial idea
+
+User passed short description. You extract:
+- Project type (web app / cli / api / lib / mobile)
+- Mentioned stack
+- Apparent scope
+
+If description empty or ambiguous, AskUserQuestion: "Describe in 1-2 sentences what you want to build."
+
+### Step 2: 4 key questions (AskUserQuestion, one at a time)
+
+**Q1 — Vision in 1 sentence**
+"In 1 sentence, what's the main goal of the app?"
+Free text. Goes into PROJECT.md as `vision`.
+
+**Q2 — Stack confirmation/edit**
+"Stack confirmed?"
+Show inference from the description. Options:
+- "Yes, matches description"
+- "Edit (I'll type)"
+- If not mentioned: offer 3-4 common stacks based on type
+
+**Q3 — Code design**
+"Which code-design for the project?"
+Options:
+- DDD (Domain-Driven Design)
+- Vertical Slice
+- Clean Architecture
+- Hexagonal (Ports & Adapters)
+- The Method (Juval Löwy)
+- "Don't know, suggest" (-> recommend based on type + stack)
+
+Locked for the life of the project (global rule).
+
+**Q4 — MVP scope**
+"Which minimum features for the MVP? (comma-separated)"
+Free text. Each item becomes a phase.
+
+**Q5 — LLM provider** (optional, default Anthropic)
+"LLM provider for this project's agents? (mainly affects OpenCode)"
+Options:
+- (a) Anthropic Claude (JDI default — uses CLI config, no extra)
+- (b) Local Ollama (asks URL + model name)
+- (c) OpenAI direct (asks model: gpt-5, gpt-4o, etc)
+- (d) Custom via openai-compatible (asks provider name + npm package + URL + model)
+- (e) Skip — not using OpenCode
+
+**Sub-questions if Ollama (b):**
+- "Ollama URL? (default: `http://localhost:11434/v1`)"
+- "Model name? (e.g. `llama3.1:70b`, `glm-5.1:cloud`)"
+- "Does the model support tools/function-calling? (yes/no — default yes)"
+
+**Sub-questions if Custom (d):**
+- "Provider name? (e.g. `together`, `openrouter`)"
+- "NPM package? (default `@ai-sdk/openai-compatible`)"
+- "Base URL?"
+- "Model name (with provider prefix, e.g. `together/meta-llama-3-70b`)?"
+- "Supports tools? (yes/no)"
+
+Save result to `llm_config` in PROJECT.md. Used by `/jdi-bootstrap` to:
+- Replace `{LLM_OPENCODE_MODEL}` placeholder in specialist templates
+- Merge `provider:` + `agent.<jdi-{name}>.model` into `.opencode/opencode.jsonc` automatically
+
+### Step 3: Focused research (optional, stack-based)
+
+If stack mentions a recent framework (React 19, .NET 10, etc), do a quick lookup:
+
+```bash
+# Example for React 19
+npx ctx7@latest library "React" "React 19 server components stable" 2>/dev/null | head -20
+```
+
+Capture 2-3 key facts (e.g. "React 19 introduced stable Actions", "use server required in SC").
+
+Don't go deep. Max 2 lookups. If ctx7 unavailable, skip.
+
+### Step 4: Generate PROJECT.md
+
+Path: `.jdi/PROJECT.md`
+
+```markdown
+# {project_name}
+
+## Vision
+{Q1 answer}
+
+## Type
+{web app|cli|api|lib|mobile}
+
+## Stack
+- Language: {language}
+- Framework: {framework}
+- Version: {version}
+- Key dependencies: {list}
+
+## Code Design
+**LOCKED:** {Q3 answer}
+
+Decided in /jdi-new. Do not change.
+
+## Slug
+{project_slug}  <- used in commits, branches, specialist names
+
+## Research notes (if any)
+- {fact 1}
+- {fact 2}
+
+## Global constraints (from user CLAUDE.md)
+- Minimum coverage 80%
+- Conventional commits
+- Atomic commits per task
+- Language: code in English, discussion in English
+
+## LLM config
+
+```yaml
+llm_config:
+  default_model_opencode: {model chosen in Q5}
+  # if Q5 != Anthropic, append provider:
+  # provider:
+  #   name: {ollama|openai|custom}
+  #   npm: {package}
+  #   display_name: {name}
+  #   baseURL: {url}
+  #   models:
+  #     - id: {model_id}
+  #       name: {label}
+  #       tools: {true|false}
+```
+
+Applied by `/jdi-bootstrap` to `.opencode/opencode.jsonc`. Other runtimes ignore.
+```
+
+### Step 5: Generate ROADMAP.md
+
+Path: `.jdi/ROADMAP.md`
+
+Each MVP feature (Q4) becomes 1 phase. Short name + slug.
+
+```markdown
+# {project_name} — Roadmap
+
+## Status
+current_phase: 1
+total_phases: {N}
+
+## Phases
+
+### Phase 1: {feature 1 name}
+- **Slug:** 01-{slug}
+- **Status:** pending
+- **Goal:** {1-line description}
+
+### Phase 2: {feature 2 name}
+- **Slug:** 02-{slug}
+- **Status:** pending
+- **Goal:** {1-line description}
+
+(... up to N)
+```
+
+### Step 6: Generate initial state files
+
+```markdown
+# .jdi/STATE.md
+project_slug: {slug}
+specialists_ready: false
+current_phase: 1
+next_step: /jdi-bootstrap
+```
+
+```markdown
+# .jdi/DECISIONS.md
+# Locked project decisions
+
+D-1 ({date}): Code design locked = {Q3}
+```
+
+### Step 7: mkdir + .gitattributes
+
+```bash
+mkdir -p .jdi/phases
+mkdir -p .jdi/agents
+```
+
+Do NOT create empty placeholders for `specialists.md`, `reviewers.md`, `registry.md`. Architect (specialist mode) creates them populated when `/jdi-bootstrap` runs.
+
+Create `.gitattributes` at root to normalize line endings (avoids CRLF warnings on Windows):
+
+```
+* text=auto eol=lf
+*.{cmd,bat,ps1} text eol=crlf
+*.{png,jpg,jpeg,gif,webp,ico,pdf,zip,tar,gz} binary
+```
+
+### Step 8: Commit
+
+```bash
+git init -q 2>/dev/null  # in case it's not a repo yet
+git add .jdi/ .gitattributes
+git commit -m "chore(jdi): initialize {project_name}"
+```
+
+### Step 9: Confirm
+
+```
+{project_name} ({slug}) ok. Stack: {stack}. Design: {design}. Phases: {N}.
+Files: .jdi/{PROJECT,ROADMAP,STATE,DECISIONS}.md
+Next: /jdi-bootstrap
+```
+
+</process>
+
+<rules>
+- Maximum 4 questions in Step 2 — do not expand
+- Maximum 2 web lookups in Step 3 — save tokens
+- Code design is LOCKED — always record D-1
+- Slug auto-generated: lowercase, kebab-case, no accents
+- Never create phases without user features — empty phases = scope creep
+- PROJECT.md max 80 lines. Concise.
+</rules>
+
+<fallbacks>
+- No AskUserQuestion: print numbered questions, read text input
+- No WebSearch/ctx7: skip Step 3, no research
+- Non-empty directory: AskUserQuestion "Detected existing code. Recommended to run /jdi-adopt instead of /jdi-new (auto-detects stack + sets adopted=true flag). Options: [Cancel and run /jdi-adopt] / [Continue with /jdi-new anyway] / [Cancel everything]". Default: cancel and run /jdi-adopt.
+</fallbacks>
+
+<output>
+- `.jdi/PROJECT.md`
+- `.jdi/ROADMAP.md`
+- `.jdi/STATE.md`
+- `.jdi/DECISIONS.md`
+- `.jdi/phases/` (empty, ready for phases)
+- `.jdi/agents/` (empty, ready for bootstrap)
+- `.gitattributes` (root, normalizes line endings)
+- Initial commit
+- Final message with next step
+</output>
+</output>

package/runtimes/antigravity/skills/jdi-ship/SKILL.md

@@ -0,0 +1,146 @@
+---
+name: jdi-ship
+description: Finalizes phase after verify. Updates ROADMAP.md, marks phase as done, advances pointer to next.
+argument_hint: "<phase_number>"
+runtime_intent:
+  invokes_agent: none
+runtime_overrides:
+  claude:
+    allowed-tools: [Read, Write, Edit, Bash, Grep, Glob, AskUserQuestion]
+  copilot:
+    tools: [read, write, edit, grep, glob, terminal]
+  opencode:
+    subtask: true
+  antigravity:
+    triggers:
+      - "/jdi-ship"
+      - "finalize phase {N}"
+---
+
+<objective>
+Finalizes phase after /jdi-verify approves. Updates ROADMAP.md (phase: done), advances STATE to next phase, final commit.
+</objective>
+
+<arguments>
+- `phase_number` (required)
+</arguments>
+
+<process>
+
+### Step 1: Validation
+```bash
+test -d .jdi/ || { echo "Not a JDI project."; exit 1; }
+
+# Verify REVIEW.md exists
+ls .jdi/phases/{NN}*/REVIEW.md 2>/dev/null || {
+  echo "REVIEW.md missing. /jdi-verify {N}."
+  exit 1
+}
+
+# Read verdict
+VERDICT=$(grep -oE 'Verdict:\*\* (APPROVED|APPROVED_WITH_WARNINGS|BLOCKED)' .jdi/phases/{NN}*/REVIEW.md | awk '{print $2}')
+
+if [ "$VERDICT" = "BLOCKED" ]; then
+  echo "Phase {N} BLOCKED. Fix before ship."
+  exit 1
+fi
+```
+
+### Step 2: Confirm with user (only if WITH_WARNINGS)
+
+If `VERDICT=APPROVED_WITH_WARNINGS`:
+```
+Phase {N} has uncorrected warnings. Ship anyway?
+- Yes, ship (warnings remain in REVIEW.md)
+- No, fix first
+```
+
+If "No" -> exit clean.
+
+### Step 3: Update ROADMAP.md
+
+Edit `.jdi/ROADMAP.md`:
+- Phase {N}: `status: done`
+- Phase {N+1}: `status: ready` (if exists)
+
+If no phase {N+1}:
+```
+All phases complete.
+Project delivered.
+```
+
+### Step 4: Update STATE.md
+
+```markdown
+current_phase: {N+1 or done}
+phase_status: ready (if {N+1} exists) or complete
+next_step: /jdi-discuss {N+1} or done
+```
+
+### Step 5: Archive old phases (compaction)
+
+Read `archive_after` from `.jdi/config.json` (default 5). If current phase advances to `N+1`, and a phase exists with number `<= (N+1) - archive_after`, move to `.jdi/archive/`.
+
+```bash
+ARCHIVE_AFTER=5
+if [ -f .jdi/config.json ]; then
+  if command -v jq >/dev/null 2>&1; then
+    ARCHIVE_AFTER=$(jq -r '.compaction.archive_after // 5' .jdi/config.json)
+  fi
+fi
+
+NEXT=$((N + 1))
+THRESHOLD=$((NEXT - ARCHIVE_AFTER))
+
+if [ "$THRESHOLD" -ge 1 ]; then
+  mkdir -p .jdi/archive
+  test -f .jdi/archive/index.md || echo "# Archive index" > .jdi/archive/index.md
+
+  for dir in .jdi/phases/*/; do
+    NN=$(basename "$dir" | grep -oE '^[0-9]+' || true)
+    [ -z "$NN" ] && continue
+    NN_NUM=$((10#$NN))  # force decimal
+    if [ "$NN_NUM" -le "$THRESHOLD" ]; then
+      VERDICT_OLD=$(grep -oE 'Verdict:\*\* (APPROVED|APPROVED_WITH_WARNINGS|BLOCKED)' "$dir/REVIEW.md" 2>/dev/null | awk '{print $2}' || echo "UNKNOWN")
+      mv "$dir" .jdi/archive/
+      echo "- $(basename "$dir"): ${VERDICT_OLD} (archived $(date -u +%F))" >> .jdi/archive/index.md
+    fi
+  done
+fi
+# Windows: equivalent in PowerShell — Move-Item + Add-Content
+```
+
+Archived phases remain accessible via `.jdi/archive/` but exit the default read-path. Read-depth rule (`ARCHITECTURE.md > Read-depth scaling`) treats archive as `<= current - 2`.
+
+### Step 6: Final commit
+
+```bash
+git add .jdi/ROADMAP.md .jdi/STATE.md .jdi/archive/ 2>/dev/null
+git commit -m "feat({NN-slug}): ship phase {N} ({VERDICT})"
+```
+
+Optional tag (if PROJECT.md has `tag_phases: true`):
+```bash
+git tag "phase-{N}-{slug}"
+```
+
+### Step 7: Confirm
+
+```
+Phase {N} shipped.
+{if more phases:} Next: /jdi-discuss {N+1}
+{if last:} Project delivered. Tag: phase-{N}-{slug}
+```
+
+</process>
+
+<gates>
+- pre: REVIEW.md exists + verdict != BLOCKED
+- post: ROADMAP.md + STATE.md updated + old phases archived (if applicable) + commit (+ optional tag)
+</gates>
+
+<errors>
+- REVIEW missing -> /jdi-verify
+- Verdict BLOCKED -> abort
+- Already shipped -> abort with warning
+</errors>