# Problem Solver

> https://problem-solver.skillsafe.ai/
> Describe a problem in your own words and get it decomposed — classified into one of seven
> problem types first, because a decision, a diagnosis, a negotiation and a debugging job want
> genuinely different scaffolding, and a breakdown that could apply to any problem has failed.

## What it does

You paste a problem the way you would say it out loud. You get back:

- **The problem type**, one of seven, each with its own frame: `decision`, `diagnosis`,
  `debugging`, `negotiation`, `prioritisation`, `interpersonal`, `execution`. Each frame asks five
  fixed questions — the spine that makes two breakdowns of a type comparable — plus a **sixth
  question written for that problem alone**, which is what stops a per-type rubric reading as one
  template in nine costumes.
- **A reframe, at the top**, when the stated problem is not the real one. Seven kinds:
  `wrong_problem`, `excluded_option`, `hidden_objective`, `false_binary`, `not_yet_a_problem`,
  `constraint_is_soft`, and `none` — used honestly, because a manufactured reframe is worse than
  no reframe. Every reframe must quote the user's own text or it is demoted.
- **What you are optimising for**, including at least one objective you did not state out loud.
- **Constraints split into `hard`, `soft` and `assumed`**, and every assumed one carries a
  concrete cheap test that would establish whether it is real. That is where the leverage is.
- **The unknowns** that would change the answer, with the cheapest way to learn each.
- **The options**, each with what it gets you, what it costs you, the condition under which it is
  the wrong choice, and how reversible it is. Options the user already ruled out are marked as
  such and revisited rather than silently re-suggested.
- **One first move**, sized for this week, with a date.
- **Falsification signals** — what would show it is working and, more importantly, what would show
  it is not, written so they are hard to rationalise past.

## The free lane

A client-side pass runs in the browser before anything is spent and is useful on its own. It
extracts the constraints, goals, already-rejected options, other parties, deadlines and quantities
that are literally in the text, each with the phrase that triggered it; classifies the problem and
shows which phrases it scored on; and scores how specific the description is, naming what is
missing. Those findings are sent with the run, and afterwards the app reconciles the breakdown
against them and reports what it did not address.

## Second runs

A follow-up carries the prior breakdown plus what actually happened, as `tried_it`,
`constraint_changed` or `new_information`. It returns a `delta` — what held, what changed, what the
previous breakdown got wrong, and a status — rather than a restatement. History is stored in a
declared collection keyed by `thread_id`, so a problem and its follow-ups stay together.

## Boundaries

Problem Solver is not a doctor, a lawyer, a financial adviser or a therapist. Medical, legal,
financial and mental-health material is detected in the browser before any request is made: the
app renders its own boundary card, sends the domain with the run so the prompt binds on it, and
re-checks the reply for prescriptive drift afterwards. Material suggesting self-harm stops the
request entirely and surfaces crisis lines instead of a decomposition.

## Interface

- Single contract, no lane router. Input: `shape` (`first-pass` | `revision`), `problem`, and
  optionally `facts`, `professional_domains`, `frame_override`, and on a revision `prior`,
  `update`, `update_kind`.
- Output: one JSON object. Full field list and enums at https://problem-solver.skillsafe.ai/api.html
- API base: `https://api.skillsafe.ai/v1/app-api` — `/me`, `/estimate` (free), `/run`,
  `/run-stream`. Tokens: https://problem-solver.skillsafe.ai/tokens.html
- Model: `gpt-terra`. Runs are metered; the free client-side lane is not.

## Pages

- https://problem-solver.skillsafe.ai/ — the app
- https://problem-solver.skillsafe.ai/api.html — API tutorial in eight languages