Decision Tree Solver

---
name: decision-tree-solver
description: "Turn a fork-in-the-road decision into a computed expected-value tree — settle or sue, launch or wait, fix or replace — rolled back by the bundled script, with the break-even probability where the answer flips. Use when asked should we settle or go to trial, build a decision tree, what probability makes this worth it, or compare options under uncertainty. Produces the structured tree, the rollback with the best choice at every fork, the break-even probabilities, and the honest list of what the numbers leave out. Decision support, not advice — the probabilities are yours."
homepage: https://mohitagw15856.github.io/pm-claude-skills/skill/decision-tree-solver.html
metadata:
  {
    "openclaw": { "emoji": "🧮" }
  }
---

# Decision Tree Solver

"Should we settle or go to trial" is not answered by instinct or by whoever argues longest — it is three numbers and a probability, and most people have never actually multiplied them. This skill extracts the tree hiding inside a messy decision (the choices, the chances, the payoffs, the costs of playing), computes the rollback with the bundled script, and — the part instinct can never do — finds the break-even: the probability at which the recommendation *flips*. Because "trial is worth it if you win 60% of the time" is an opinion, but "the answer flips at 90% — are you more than 90% sure?" is a decision made tractable. The script is deterministic, stdlib-only, and shows its arithmetic.

## What This Skill Produces

- **The extracted tree** — decisions, chance nodes with probabilities, outcomes with values, and the costs of each path, pulled from the situation as described
- **The rollback** — expected value at every node, the best choice named at every fork, from the script
- **The break-even scan** — for each two-way uncertainty, the probability at which the top-level choice flips, which is the number that makes probability arguments productive
- **The robustness read** — whether the answer survives the probabilities being argued about, or hinges on a number nobody can defend
- **The leaves-out list** — what expected value cannot see here: risk appetite, one-shot vs repeated, the unquantified costs

## Required Inputs

Ask for these if not provided:
- **The choices** — the real options on the table, including the do-nothing one
- **The uncertainties** — what could happen under each choice, and the requester's honest probability for each (pushing back on false precision is part of the job)
- **The payoffs and costs** — the money (or a stated proxy) at each end point, and what each path costs to walk: fees, time priced honestly, deposits
- **The stakes context** — one-shot or repeatable, and whether the worst branch is survivable — because expected value is the right tool for repeatable bets and needs a caveat for ruinous one-shots

## Framework: Extract, Roll Back, Stress the Probabilities

1. **Extract before computing.** The tree is usually mis-drawn before it is mis-computed: options that are really the same option, a "risk" that is actually two sequential risks, a payoff that forgot the cost of getting it. Draw it in the script's JSON, read it back to the requester, fix it *there*.
2. **Run the rollback.**
   ```
   python3 scripts/decision_tree.py --input tree.json          # tree with EVs and best choices
   python3 scripts/decision_tree.py --input tree.json --json   # machine-readable
   python3 scripts/decision_tree.py --demo                     # settle-vs-trial worked example
   ```
   Outcomes carry values; chance nodes take probability-weighted sums; decisions take the best child; costs subtract along the way. The best path falls out, with the arithmetic visible.
3. **Read the break-even before the recommendation.** The scan reports where the choice flips. A decision that holds from p=0.3 to p=0.9 is robust and the probability argument can stop; one that flips at 0.55 when the room believes 0.5-to-0.6 is *the argument itself*, now named precisely.
4. **Stress the values too.** Nudge the big payoffs ±30% and rerun. An answer that survives sloppy values and sloppy probabilities is a real answer; one that does not is a request for better information, and the tree shows exactly which information.
5. **Say what EV cannot see.** A 10% chance of ruin is not "priced in" by multiplication for someone who cannot survive it once; reputational and relationship costs sit outside the tree unless explicitly valued. The recommendation carries these as words, not silently.

## Output Format

### Decision tree: [the decision] · [date]

**The tree** (as computed — from `decision_tree.py`)
```
[rendered tree: choices ▣, chances ◔, outcomes •, EV at every node, best marked]
```

**Recommendation:** [the best path] · **EV [amount]** vs next-best [amount]

**Break-even scan**
| Uncertainty | Flips the choice at | You believe | Verdict |
|---|---|---|---|
| [chance node] | p ≈ [x] | [their estimate] | robust / hinges here |

**Value stress:** [the payoffs nudged ±30% — held / flipped, and on which number]

**What the numbers leave out:** [ruin risk on the worst branch · one-shot vs repeated framing · the unpriced costs, named]

> Decision support, not legal, financial, or any other advice. The probabilities are the requester's own beliefs made explicit — the tree cannot make them true, only make their consequences consistent.

## Quality Checks
- [ ] The tree was read back and corrected before anything was computed
- [ ] Every path's costs are on the path, not forgotten at the leaves
- [ ] The break-even scan appears and is compared against the requester's stated belief
- [ ] Values were stressed, not just probabilities
- [ ] The leaves-out list names ruin risk explicitly when the worst branch is severe
- [ ] The recommendation states robustness, not just the EV winner

## Anti-Patterns
- **Computing the mis-drawn tree.** Ten minutes of extraction beats any amount of arithmetic on the wrong structure.
- **False precision in probabilities.** "About 60%" is honest; "62.5%" from nowhere is decoration — the break-even scan is the cure, since it shows whether the difference even matters.
- **EV-maximising a ruinous one-shot.** The tool's cleanest failure mode; the caveat is mandatory, not optional.
- **Hiding the arithmetic.** The script prints every node's EV because a recommendation nobody can check convinces nobody who matters.
- **Letting the tree end the conversation.** It ends the *circular* part; the values conversation it surfaces is the productive one.