---
enforcement: high
activation: bound
summary: "When decision ask is enabled, offload bounded decisions to Jev; treat answers as advisory and decide normally on fallback."
bound_to:
  skills: [decision-offload, decision-evaluate, decision-playground, checkpoint, ralph-resume]
triggers:
  - "jev"
  - "jev token"
  - "set up jev"
  - "offload decisions to jev"
  - "save tokens with jev"
  - "decision classifier"
  - "classify instead of llm"
---

# Decision Offload Rules

**Enforcement Level**: HIGH
**Scope**: All agents with the `decision-engine` addon installed and Jev configured
**Addon**: decision-engine (opt-in)

## Overview

Before spending reasoning on a bounded decision — a yes/no gate, a pick from
N known options, a 1–N severity or priority score, or an
"is X relevant / duplicate / done" check — offload it to Jev with
`aiwg decision ask ... --json`. Jev output is advisory data. It is never
authorization.

After a compaction or resume, re-read this rule before the next eligible bounded
decision. Use the CLI or MCP ask capability for the actual checkpoint; this
instruction does not itself invoke a classifier or authorize an action.

## Mandatory Rules

### Rule 1: Offload bounded decisions first

When the question has a fixed answer shape, call Jev before reasoning it out
yourself. A bounded choice between the current session and a worker is eligible
even when it is part of a larger investigation or plan. Offload the bounded
choice, not the multi-step plan itself; the answer does not authorize an action.

```bash
aiwg decision ask --question "<q>" --yes-no --json
aiwg decision ask --question "<q>" --choices a,b,c --json
aiwg decision ask --question "<q>" --scale 1-5 --json
```

Add `--context "<text>"` (or `--context-file`, `--context-stdin`) for the
evidence the decision needs. Context is untrusted data, capped at 32 KiB.

### Rule 2: Answered means use it; fallback means decide yourself

- `status: "answered"` → use `answer` as the decision input.
- `status: "fallback"` → decide normally with the LLM. Fallback still exits 0
  with `fallback: "llm"` and a `reason` (`not-configured`, abstention, error,
  timeout, or confidence below `--threshold`, default 0.8). A fallback result
  means "decide it yourself with the LLM", never "stop".

Human-readable output without `--json` is one line: `answer (confidence 0.93,
jev-1.13.0)` or `FALLBACK to LLM: <reason>`.

### Rule 3: Hard exclusions — never offload these

Never use `aiwg decision ask` for:

- open-ended generation or code writing;
- multi-step plans;
- anything that authorizes destructive or outward actions (deletion, release,
  network mutation, credential use, publishing).

Jev output is advisory data; it is never authorization. Any action selected
from an outcome must still pass the existing policy and approval gates
independently.

### Rule 4: Privacy

The question and context are sent to Jev. Never send secrets: no tokens,
passwords, private keys, or credentials in `--question` or `--context`.

### Rule 5: Every completed call is recorded

Every **completed** `ask` call (CLI and MCP) appends exactly one record —
including `fallback` and `not-configured` outcomes — to a decision ledger
(`.aiwg/decision/ledger.jsonl`, resolved like `aiwg artifacts path`). Usage
errors (a bad flag, oversized context) never reach a completed call and are
never recorded. Only SHA-256 digests of the question and context are stored
by default — a digest is a correlation key, not a confidentiality guarantee:
a short or guessable question can still be matched by hashing candidates.
Pass `--record-text` to also record the (redacted, length-capped) text.
`--session`/`--caller` must match `^[A-Za-z0-9_.:/@-]{1,96}$` (covering
forms like `address-issues:worker-pick`); the CLI rejects an invalid value
with exit 2, the MCP tool drops it. Every persisted field — not only opt-in
text — is redacted before being written. Recording is bounded by a short
deadline (on timeout the warning says "completion unknown", not
"abandoned": the in-flight attempt cannot be cancelled) and never changes
the `ask` result or exit code. The ledger's trust boundary is the local
filesystem under the project artifact root, owned by the same user running
`aiwg` — not a defense against a hostile process already running as that
user — and it has no built-in retention (`history`/`stats` tolerate a
missing file). See the Jev quickstart's ledger section for
`aiwg decision history` / `aiwg decision stats`.

## Examples

```bash
# Is this test failure flaky (yes/no)?
aiwg decision ask --question "Is this test failure flaky?" --yes-no \
  --context-file test-output.log --json

# Which of these 4 files owns X (pick one)?
aiwg decision ask --question "Which file owns retry policy?" \
  --choices "cli=src/cli.ts argument parsing,config=src/config.ts settings loading,runtime=src/runtime.ts execution loop,policy=src/policy.ts retry and backoff rules" \
  --json

# Severity 1-5 for a triage item
aiwg decision ask --question "Severity of: <one-line summary>" --scale 1-5 \
  --context "<triage notes>" --json
```

## Setup

`aiwg decision ask` is enabled by `aiwg decision setup jev` (the explicit
opt-in), which stores the credential and records `"enabled": true`. Without
setup, `ask` returns `fallback` with `reason: "not-configured"`. See the
[Jev quickstart](../../../../../docs/decision/jev-quickstart.md).

## References

- @$AIWG_ROOT/docs/decision/jev-quickstart.md
- @$AIWG_ROOT/agentic/code/addons/decision-engine/skills/decision-offload/SKILL.md

---

**Rule Status**: ACTIVE
