/d

name: d
version: "2.0.0"
description: "Request router: picks the agent, skill, and pipeline with /do's rules, then uses Jev to validate the requested outcome and attach extra skills."
user-invocable: true
argument-hint: "[request]"
allowed-tools:
  - Read
  - Bash
  - Grep
  - Glob
  - Skill
  - Agent
routing:
  triggers:
    - "jev router"
    - "route with jev"
    - "use the d router"
  not_for: "General-purpose task execution — /d classifies and dispatches, it does not perform the work itself."
  category: meta-tooling

/d — Jev Router

Routes a request in four parts. A deterministic `pre-route.py` guard keeps git/PR and security work on their quality gates. You, the session model, pick the agent, skill, and pipeline from the full routing manifest with `/do`'s rule text. Jev answers the attachment questions that add extra skills, and validates that the restated outcome survives the route. A script validates your pick and computes the attachments.

Design rationale: `${CLAUDE_SKILL_DIR}/references/jev-classifier-design.md`.

Phase Banners

Every phase: `/d > Phase N: PHASE_NAME — description...` After intent alignment resolves: `===` routing banner. Both required.

---

Phase 1: CLASSIFY

Resolve `$SDIR`: `${HOME}/.claude/scripts`, falling back through `.gemini`/`.hermes`/`.factory`/`.codex`/`.reasonix`, or the repo's `scripts/` directory.

**Step 1 — JEV_RESULT.** When `JEV_RESULT` is already in context (the `jev-route-injector` hook ran the script before your first token), use it and skip the command below.

REQUEST_FILE=$(mktemp); printf '%s' "{user_request}" > "$REQUEST_FILE"
python3 "$SDIR/jev-route.py" --request-file "$REQUEST_FILE" --json-compact

Fields: `available`, `jev_called`, `source`, `forced`, `stack`, `project`, `signals`, `signal_scores`, `domain_scores`, `error`, `latency_ms`, `usage`. `forced` is the safety force route (`pr-workflow`, `pr-pipeline`, `security`) or `null`. `project` holds the request repository's languages, frameworks, and datastores (names only) or `null`. `error` is set when Jev was unavailable or its answers were unusable. Routing continues, and `attach` then carries only the pre-route stack and the agent domain floor.

**Step 2 — Pick.** Set the complexity from `/do` Phase 1 (Trivial, Simple, Medium, Complex). Trivial: go to Phase 1T.

For Simple and above, load `/do`'s routing rules and the manifest. Read the rule text in full and apply every rule:

python3 "$SDIR/print-route-rules.py"
bash "$SDIR/get-routing-manifest.sh" --request-file "$REQUEST_FILE"

The manifest is large. If Bash truncates it or saves it to a file, read the whole file before you pick. Use `JEV_RESULT.project` when the request names no language or framework.

Return the decision as JSON. Do not print it:

{"agent": "<AGENTS: name or null>", "agents": ["<extra fan-out agents>"],
 "skill": "<SKILLS: name or null>", "pipeline": "<PIPELINES: name or null>",
 "complexity": "simple|medium|complex", "confidence": "high|medium|low",
 "reasoning": "<one sentence>",
 "fallback_reason": "general-purpose: <why no listed agent covers this>"}

`fallback_reason` is required when `agent` is `general-purpose`, and only then.

When `JEV_RESULT.forced` is set, its `skill` and `pipeline` are final: step 3 overrides your values for them. Pick the `agent` and `agents` that fit, as `/do` Phase 2 Step 1(a) does.

**Step 3 — Finalize.** Write `JEV_RESULT` and the decision to temporary files and run:

python3 "$SDIR/jev-route.py" --finalize --result-file "$RESULT_FILE" --decision-file "$DECISION_FILE" --json-compact
rm -f "$REQUEST_FILE" "$RESULT_FILE" "$DECISION_FILE"

Hold the output as `ROUTE`: `agent`, `agent_source`, `skill`, `skill_source`, `pipeline`, `agents`, `attach`, `stack`, `complexity`, `confidence`, `reasoning`, `fallback_reason`, `source`, `signals`, `domain_scores`, and `problems`. The script checks every name against the live manifest, applies the safety force route, fills an empty skill with `workflow`, and gives a null or `general-purpose` agent the owning agent of the skill. `attach` is the list of extra skills that ride with `skill` (for example `programming` for Go work, `testing` when tests are part of the work). It is the whole Phase 4 stack.

**Gate**: `problems` empty → Phase 2. `problems` set → fix the decision, run step 3 once more, and carry any problem that remains into `task_spec.gaps`. The output has an `error` key and no route fields → use your decision as `ROUTE` with `attach` set to `[]`.

---

Phase 1T: TRIVIAL (complexity == Trivial)

Direct-handling path. It still goes through Phase 2 so the user outcome is restated and Jev validates it; use `{"complexity": "trivial"}` as the route file. After an aligned Phase 2 result, show `Classification: Trivial`, then answer or do the one-line action directly. Do not run Phases 3–5 or call `build-dispatch.py`. Stop there.

---

Phase 2: ALIGN INTENT (required for every /d route)

**MANDATORY STOP:** For every `/d` invocation, write `PROPOSED_INTENT` and run the validator on that exact text before any routing banner, dispatch, answer, edit, or other action. This requirement has no exception for force routes or trivial routes.

Before selecting the work method, write `PROPOSED_INTENT`: a concise one- or two-sentence restatement of what the user wants accomplished. State the outcome and each deliverable the request names or directly requires. Copy every explicit constraint in the user's words: limits ("only", "at most"), exclusions ("don't touch", "do not deploy"), required methods, and authorization boundaries. Do not add deliverables the user did not ask for, such as extra tests, docs, cleanup, refactors, or verification steps. Do not add notes about missing inputs or preconditions; the validator decides whether clarification is needed. Do not describe the selected agent, skill, or implementation mechanics as the outcome. Preserve the user's words where pre