rsc-universal 0.1.1

package/skills/ollama/references/api.md

@@ -0,0 +1,148 @@
+# Ollama local API reference
+
+Daemon base URL: `http://localhost:11434`. Bind elsewhere with `OLLAMA_HOST=0.0.0.0:11434`.
+Two surfaces share the daemon: the **native** API (`/api/*`) and the **OpenAI-compatible** layer
+(`/v1/*`).
+
+## Native endpoint catalog
+
+| Method | Path | Purpose |
+| --- | --- | --- |
+| POST | `/api/generate` | single-turn completion (`prompt`) |
+| POST | `/api/chat` | multi-turn chat (`messages`); supports `tools`, `images`, `think` |
+| POST | `/api/embed` | embeddings (`input` string or array); legacy alias `/api/embeddings` |
+| POST | `/api/create` | create a model from a Modelfile / quantize |
+| POST | `/api/pull` | download a model |
+| POST | `/api/push` | upload a model |
+| POST | `/api/show` | model template, params, context length, quant |
+| POST | `/api/copy` | duplicate a model under a new name |
+| DELETE | `/api/delete` | remove a model |
+| GET | `/api/tags` | models on disk (≈ `ollama list`) |
+| GET | `/api/ps` | models loaded in memory (≈ `ollama ps`) |
+| GET | `/api/version` | daemon version |
+
+## Request fields (generate / chat)
+
+| Field | Type | Default | Notes |
+| --- | --- | --- | --- |
+| `model` | string | — | **required**; a pulled tag |
+| `prompt` | string | — | `/api/generate` only |
+| `messages` | array | — | `/api/chat`; `{role, content, images?, tool_calls?}` |
+| `stream` | bool | `true` | NDJSON stream; set `false` for a single object |
+| `format` | string \| object | — | `"json"` or a JSON Schema object to constrain output |
+| `options` | object | — | runtime params: `temperature`, `num_ctx`, `top_p`, `seed`, `num_predict`, `stop`, … |
+| `keep_alive` | string \| int | `"5m"` | how long to keep loaded; `0` unloads now, `-1` keeps forever |
+| `tools` | array | — | tool/function definitions for tool calling |
+| `images` | array | — | base64 images for multimodal models |
+| `think` | bool | — | enable/disable reasoning on models that support it |
+
+`options.num_ctx` is per-request and does not persist. Bake a permanent context window into a
+Modelfile with `PARAMETER num_ctx`.
+
+## Response fields
+
+Final object (streaming or not) carries: `done` (bool), `done_reason`, `total_duration`,
+`load_duration`, `prompt_eval_count`, `prompt_eval_duration`, `eval_count`, `eval_duration`.
+Tokens/sec ≈ `eval_count / (eval_duration / 1e9)`.
+
+Streaming = NDJSON: one JSON object per line; accumulate `message.content` (chat) or `response`
+(generate) until `done: true`.
+
+```python
+import requests, json
+
+with requests.post("http://localhost:11434/api/chat",
+                   json={"model": "qwen3:8b",
+                         "messages": [{"role": "user", "content": "Count to 3."}]},
+                   stream=True) as r:
+    for line in r.iter_lines():
+        if line:
+            obj = json.loads(line)
+            print(obj.get("message", {}).get("content", ""), end="", flush=True)
+            if obj.get("done"):
+                break
+```
+
+## Structured output via `format`
+
+Pass a JSON Schema as `format`; the model is constrained to emit conforming JSON. Pair with a low
+temperature and an explicit instruction to return JSON.
+
+```bash
+curl http://localhost:11434/api/chat -d '{
+  "model": "qwen3:8b",
+  "messages": [{"role": "user", "content": "List two EU capitals as JSON."}],
+  "stream": false,
+  "options": {"temperature": 0},
+  "format": {
+    "type": "object",
+    "properties": {
+      "capitals": {"type": "array", "items": {"type": "string"}}
+    },
+    "required": ["capitals"]
+  }
+}'
+```
+
+## Tool calling
+
+Define `tools`; the response may contain `message.tool_calls`. Execute the tool, append a
+`{"role": "tool", "content": "<result>"}` message, and call again.
+
+```bash
+curl http://localhost:11434/api/chat -d '{
+  "model": "qwen3:8b",
+  "stream": false,
+  "messages": [{"role": "user", "content": "Weather in Andorra?"}],
+  "tools": [{
+    "type": "function",
+    "function": {
+      "name": "get_weather",
+      "description": "Current weather for a city",
+      "parameters": {
+        "type": "object",
+        "properties": {"city": {"type": "string"}},
+        "required": ["city"]
+      }
+    }
+  }]
+}'
+```
+
+## Embeddings
+
+```bash
+curl http://localhost:11434/api/embed -d '{
+  "model": "nomic-embed-text",
+  "input": ["first chunk", "second chunk"]
+}'
+```
+
+Returns `embeddings` (array of float arrays). For the retrieval pipeline around these vectors, that's
+`rag` / `embeddings-search`, not this skill.
+
+## OpenAI-compatible layer (`/v1`)
+
+| OpenAI path | Ollama support |
+| --- | --- |
+| `POST /v1/chat/completions` | yes — drop-in for chat |
+| `POST /v1/completions` | yes — legacy text completion |
+| `POST /v1/embeddings` | yes |
+| `GET /v1/models` | lists pulled models |
+
+Point any OpenAI SDK at the base URL with any non-empty key (it is ignored):
+
+```python
+from openai import OpenAI
+client = OpenAI(base_url="http://localhost:11434/v1", api_key="ollama")
+
+# streaming
+for chunk in client.chat.completions.create(
+        model="qwen3:8b",
+        messages=[{"role": "user", "content": "hi"}],
+        stream=True):
+    print(chunk.choices[0].delta.content or "", end="")
+```
+
+Native-only knobs (`keep_alive`, `format` as a JSON Schema, `think`) aren't expressible through the
+OpenAI layer — use `/api/chat` when you need them.

package/skills/ollama/references/hardware-sizing.md

@@ -0,0 +1,87 @@
+# Hardware sizing for local Ollama
+
+Total memory = **weights + KV cache + overhead**. People size for weights and forget the KV cache,
+then OOM at long context. Budget all three.
+
+## The quant ladder
+
+| Quant | Bytes/param | Size vs fp16 | Quality | Use it for |
+| --- | --- | --- | --- | --- |
+| fp16 | 2.0 | 100% | reference | when VRAM is abundant or you need max fidelity |
+| Q8_0 | ~1.0 | ~50% | near-lossless | quality-sensitive work that still fits |
+| Q6_K | ~0.8 | ~40% | very close to Q8 | a middle step when Q8 is just too big |
+| **Q4_K_M** | ~0.5 | ~25% | ~3–5% loss; the default | everyday local inference |
+| Q3_K_M | ~0.4 | ~20% | noticeable degradation | last resort to fit |
+| Q2_K | ~0.3 | ~15% | often unusable | rarely worth it — change model size instead |
+
+Rule: drop **model size** before dropping below Q4. A 14B at Q4_K_M beats a 70B at Q2_K on both quality
+and fit.
+
+## Weights formula
+
+```text
+weights_GB ≈ params(B) × bytes_per_param × 1.2
+# the ×1.2 absorbs runtime/format overhead; KV cache is separate (below).
+```
+
+| Model | Q4_K_M (~0.5 B/p) | Q8_0 (~1.0) | fp16 (2.0) |
+| --- | --- | --- | --- |
+| 7–8B | ~5–6 GB | ~9 GB | ~16 GB |
+| 13–14B | ~9–10 GB | ~16 GB | ~30 GB |
+| 32B | ~20 GB | ~36 GB | ~70 GB |
+| 70B | ~40–48 GB | ~75 GB | ~140 GB |
+
+## KV-cache math
+
+KV cache holds keys+values for every token in context, per layer. It grows ~linearly with context
+length and is allocated on top of the weights:
+
+```text
+kv_GB ≈ 2 (K+V) × layers × ctx_tokens × kv_dim × bytes_per_elem / 1e9
+```
+
+You don't need the exact number — you need the shape: **doubling `num_ctx` roughly doubles the cache**,
+and on big models at long context the cache can rival or exceed the weights. Illustrative, large model:
+
+| Context (`num_ctx`) | KV cache (order of magnitude) |
+| --- | --- |
+| 4K | small (≪ weights) |
+| 32K | several GB |
+| 128K | tens of GB on a 70B — often more than the headroom you assumed |
+
+Shrink it: set `OLLAMA_KV_CACHE_TYPE=q8_0` (≈ half) or `q4_0` (≈ quarter) — a small accuracy cost for a
+big memory win. Or just cap `num_ctx` to what the task needs.
+
+## Apple Silicon (unified memory)
+
+On a Mac, weights + KV cache draw from the **single unified memory pool** shared with the OS and apps.
+Budget against total RAM minus what the system needs (leave several GB). A 64 GB Mac can comfortably run
+a 32B Q4_K_M; a 70B Q4_K_M is feasible but leaves little headroom for long context.
+
+**MLX backend gate.** Ollama can run an MLX backend on Apple Silicon (shipped in Ollama 0.19, per
+[ollama.com/blog/mlx](https://ollama.com/blog/mlx), 2026-03-30), but it requires a Mac with **more than
+32 GB of unified memory** — below that gate it stays on the default llama.cpp/GGUF engine. So MLX is not
+a universal Apple-Silicon win: a 16 GB or 32 GB Mac will not use it, and your sizing math is the same
+GGUF math as everywhere else. The 64 GB row above is where MLX actually kicks in.
+
+## Env knobs to fit tight boxes
+
+| Variable | Effect |
+| --- | --- |
+| `OLLAMA_KV_CACHE_TYPE` | `q8_0` / `q4_0` quantize the KV cache → less VRAM at long context |
+| `OLLAMA_FLASH_ATTENTION` | enable flash attention → lower memory + faster on supported GPUs |
+| `OLLAMA_NUM_PARALLEL` | concurrent requests per model; more = more KV cache allocated |
+| `OLLAMA_MAX_LOADED_MODELS` | how many models stay resident at once |
+| `OLLAMA_KEEP_ALIVE` | default unload timer (overrides the 5m default) |
+| `OLLAMA_HOST` | bind address/port |
+| `OLLAMA_MODELS` | where models are stored on disk |
+
+## Decision: fit, or leave the box
+
+1. Compute `weights_GB` for the model+quant you want.
+2. Add a KV-cache budget for your target `num_ctx` (and `OLLAMA_NUM_PARALLEL`).
+3. Add ~1–2 GB OS/overhead.
+4. If the total exceeds your VRAM/unified memory: shrink `num_ctx`, quantize the KV cache, or step the
+   model down one size — **not below Q4**.
+5. If it still doesn't fit at the quality you need: it's a remote-GPU job → `runpod` (rent a GPU),
+   `modal` (serverless + autoscale), or a hosted endpoint (`replicate`, `together-fireworks`, `fal`).

package/skills/ollama/scripts/verify.sh

@@ -0,0 +1,116 @@
+#!/usr/bin/env bash
+#
+# verify.sh — static checks for a local Ollama setup.
+#
+# Usage:
+#   ./scripts/verify.sh [TARGET]      # TARGET defaults to the current directory
+#
+# What it does (all read-only, no daemon needed):
+#   1. Modelfile lint  — if a Modelfile exists under TARGET: FAIL if it has no FROM line;
+#                        WARN on unknown instructions; WARN if PARAMETER num_ctx is absurdly
+#                        high (> 32768) — a likely OOM on consumer GPUs.
+#   2. App-code scan   — note whether code points at the local localhost:11434 / /v1 endpoint;
+#                        WARN if it only references remote LLM hosts when this is meant to be local.
+#   3. Ollama presence — only if `ollama` is on PATH: best-effort `ollama list` to confirm a model
+#                        is pulled (WARN, never FAIL, if none / daemon down).
+#
+# Emits PASS / WARN / FAIL lines. Exits non-zero ONLY on a real FAIL. An empty or clean
+# target passes cleanly (exit 0). Works on stock macOS bash 3.2 — no mapfile, no assoc arrays.
+
+set -euo pipefail
+
+TARGET="${1:-.}"
+
+if [ -t 1 ]; then
+  RED=$'\033[0;31m'; GREEN=$'\033[0;32m'; YELLOW=$'\033[0;33m'; RESET=$'\033[0m'
+else
+  RED=''; GREEN=''; YELLOW=''; RESET=''
+fi
+pass() { printf '%sPASS%s %s\n' "$GREEN" "$RESET" "$*"; }
+warn() { printf '%sWARN%s %s\n' "$YELLOW" "$RESET" "$*"; }
+fail() { printf '%sFAIL%s %s\n' "$RED" "$RESET" "$*"; FAILED=$((FAILED + 1)); }
+
+FAILED=0
+
+if [ ! -e "$TARGET" ]; then
+  warn "target '$TARGET' does not exist — nothing to verify"
+  pass "verify.sh: ok (nothing to verify)"
+  exit 0
+fi
+
+# --- 1. Modelfile lint -------------------------------------------------------
+# Match Modelfile and Modelfile.* (case-insensitive), excluding VCS/deps dirs.
+MODELFILES=$(find "$TARGET" \
+  \( -name node_modules -o -name .git -o -name .venv -o -name venv \) -prune -o \
+  -type f \( -iname 'Modelfile' -o -iname 'Modelfile.*' \) -print 2>/dev/null || true)
+
+if [ -z "$MODELFILES" ]; then
+  warn "no Modelfile found under '$TARGET' — skipping Modelfile lint"
+else
+  # Known Modelfile instructions (uppercased first token of a line).
+  KNOWN=" FROM PARAMETER SYSTEM TEMPLATE LICENSE ADAPTER MESSAGE STOP "
+  # Iterate without a pipe so FAILs increment FAILED in THIS shell (bash 3.2: a piped
+  # while runs in a subshell and would lose the counter).
+  OLD_IFS=$IFS; IFS=$'\n'
+  for mf in $MODELFILES; do
+    IFS=$OLD_IFS
+    [ -z "$mf" ] && continue
+    if grep -qiE '^[[:space:]]*FROM[[:space:]]+' "$mf"; then
+      pass "Modelfile '$mf' has a FROM line"
+    else
+      fail "Modelfile '$mf' has no FROM line (required)"
+    fi
+
+    # Unknown instructions: first uppercased token on non-blank, non-comment lines.
+    while IFS= read -r line; do
+      case "$line" in ''|'#'*) continue ;; esac
+      first=$(printf '%s' "$line" | awk '{print toupper($1)}')
+      [ -z "$first" ] && continue
+      case "$KNOWN" in
+        *" $first "*) : ;;
+        *) warn "Modelfile '$mf': unknown instruction '$first'" ;;
+      esac
+    done < "$mf"
+
+    # Absurd num_ctx.
+    ctx=$(grep -iE '^[[:space:]]*PARAMETER[[:space:]]+num_ctx[[:space:]]+[0-9]+' "$mf" \
+      | awk '{print $3}' | tail -n1 || true)
+    if [ -n "${ctx:-}" ] && [ "$ctx" -gt 32768 ] 2>/dev/null; then
+      warn "Modelfile '$mf': PARAMETER num_ctx $ctx is very high — likely OOM on consumer GPUs"
+    fi
+    IFS=$'\n'
+  done
+  IFS=$OLD_IFS
+fi
+
+# --- 2. App-code scan --------------------------------------------------------
+SCAN_GLOB='--include=*.py --include=*.js --include=*.ts --include=*.go --include=*.rb --include=*.sh --include=*.env --include=*.yaml --include=*.yml --include=*.toml'
+LOCAL_HITS=$(grep -rIl $SCAN_GLOB -e 'localhost:11434' -e '127.0.0.1:11434' -e ':11434/v1' "$TARGET" 2>/dev/null || true)
+REMOTE_HITS=$(grep -rIl $SCAN_GLOB -e 'api.openai.com' -e 'api.anthropic.com' -e 'api.together.xyz' -e 'api.replicate.com' "$TARGET" 2>/dev/null || true)
+
+if [ -n "$LOCAL_HITS" ]; then
+  pass "found local Ollama endpoint (localhost:11434) in app code"
+elif [ -n "$REMOTE_HITS" ]; then
+  warn "app code references only remote LLM hosts; for a local Ollama target use http://localhost:11434/v1"
+else
+  warn "no LLM endpoint references found in app code under '$TARGET' — nothing to check"
+fi
+
+# --- 3. Ollama presence (best-effort) ---------------------------------------
+if command -v ollama >/dev/null 2>&1; then
+  if models=$(ollama list 2>/dev/null) && [ "$(printf '%s\n' "$models" | sed -n '2,$p' | grep -c .)" -gt 0 ]; then
+    pass "ollama is on PATH and at least one model is pulled"
+  else
+    warn "ollama is on PATH but no model is pulled (or daemon is down) — try: ollama pull qwen3:8b"
+  fi
+else
+  warn "ollama not on PATH — skipping runtime check (static checks still ran)"
+fi
+
+# --- summary -----------------------------------------------------------------
+if [ "$FAILED" -gt 0 ]; then
+  fail "verify.sh: $FAILED failure(s)"
+  exit 1
+fi
+pass "verify.sh: ok"
+exit 0

package/skills/orient/SKILL.md

@@ -0,0 +1,54 @@
+---
+name: orient
+description: "Always-on. The brújula: after every action keep the human oriented — situate them on the project map, say what just happened, teach the why at their level, and propose the next step as a question. NEVER end a turn in seco (dead-end). Reads technical_level + accompaniment_level from 02-DOCS/wiki/harness/user-profile.md and calibrates how much it explains; rewrites the dial when the user asks for more/less ('explícame más', 'explícame menos', 'no me expliques tanto', 'enséñame'). Complements suggest (which installs missing skills) — orient guides the person, not the toolbox. Fires on every turn that finishes an action, reaches a decision fork, or leaves the user unsure what to do next."
+tags: [orient, guide, compass, dial, meta, always-on]
+recommends: []
+profiles: [minimal, core, full]
+origin: risco
+---
+
+# orient — the brújula that never leaves the user lost
+
+You are always loaded. Your one job: **after anything happens, keep the human oriented.** A tool executes and falls silent; a mentor walks alongside. You make the harness a mentor.
+
+`suggest` keeps the *session* equipped ("you're missing a skill, install it?"). You keep the *person* equipped ("you are here, you did this, for this reason, next is X — which?"). Never duplicate `suggest`'s install prompt; that is its job.
+
+## The one rule
+
+**No turn ends in seco.** Every turn that finishes an action, reaches a fork, or could leave the user unsure closes with the brújula block, calibrated to the dial.
+
+## The brújula block
+
+Close the turn with these four intents (the wording adapts; the intents are fixed):
+
+```
+📍 Dónde estás — the project phase/state (the map)
+✅ Qué acabas de hacer — one line, in the user's language
+🧭 Por qué — the technical why, scaled to the dial
+➡️ Siguiente — 1-3 concrete options, ending in a question. Never in seco.
+```
+
+## Calibrate to the dial
+
+Read `02-DOCS/wiki/harness/user-profile.md` before you write the block. Two fields combine: `accompaniment_level` (how deep the block goes) and `technical_level` (the vocabulary).
+
+| accompaniment_level | How the block behaves |
+|---------------------|-----------------------|
+| L0 — cavernícola | Only `✅` + `➡️`. One next option, a yes/no question. |
+| L1 — breve | The four lines; `🧭` is one line of why. |
+| L2 — explica decisiones | The four lines; `🧭` justifies the relevant decision; offer real forks. |
+| L3 — acompañamiento total | The four lines, full why, many orienting questions, each option explained in plain language. |
+
+`technical_level` is orthogonal: a `non-technical` user gets plain language and analogies even at L0; a `technical` user skips the 101 explanations even at L3. If the profile is missing, assume `non-technical` + **L3** (the non-technical-first default) and offer to set the dial.
+
+## Spoken dial config
+
+When the user says "explícame más / menos", "no me expliques tanto", or "enséñame", update `accompaniment_level` in `02-DOCS/wiki/harness/user-profile.md`, confirm the change in one line, and apply the new depth from this turn on.
+
+## Rules
+
+- Adapt tone to the dial — you are a **flexible** skill, not a rigid template.
+- One brújula block per turn, at the end. Do not interrupt mid-work to orient.
+- Ask before deciding at any real fork; do not decide alone when the user can choose.
+- Never invent project state — situate the user from what is actually built (read the Knowledge map / repo if unsure).
+- Defer the "install a missing skill?" prompt to `suggest`.

package/skills/orient/evals/README.md

@@ -0,0 +1,16 @@
+# Evals — orient
+
+The always-on brújula. These cases check that it keeps the user oriented at the end of a
+turn (map + what happened + why-at-level + next step as a question) and that it defers
+install prompts to `suggest` and never interrupts trivial mid-flow edits.
+
+| Prompt | Expected |
+|---|---|
+| "ya está instalado, ¿y ahora qué?" | situate + next step as a question |
+| "no sé por dónde seguir" | render the map + 1-3 next options |
+| "explícame menos" | lower the dial, confirm, apply reduced depth |
+| "renombra esta variable" | no full brújula block (trivial mid-flow) |
+| "necesito una base de datos" | defer to `suggest` (no duplicate install prompt) |
+
+A pass = orient closes the turn without leaving the user in seco, scales the why to the
+dial, and never duplicates `suggest`'s install prompt.

package/skills/orient/evals/cases.yaml

@@ -0,0 +1,57 @@
+skill: orient
+
+# The always-on brújula. It fires at the END of a turn to keep the user oriented:
+# map + what happened + why (scaled to the dial) + a next step phrased as a question.
+# It defers "install a missing skill?" to suggest and does not interrupt mid-work.
+
+should_trigger:
+  - prompt: "Ya está instalado el postgresdb. ¿Y ahora qué?"
+    why: "An action just finished and the user is explicitly unsure what to do next — orient must situate them and propose the next step."
+
+  - prompt: "Vale, hemos creado la landing. ¿Qué hago con esto?"
+    why: "A step finished and the user asks for direction — orient closes with the map + next options as a question."
+
+  - prompt: "No sé por dónde seguir con mi proyecto."
+    why: "The user is lost — the core trigger: situate on the map and propose 1-3 next steps."
+
+  - prompt: "Explícame menos, que me agobio con tanto detalle."
+    why: "A spoken dial request — orient lowers accompaniment_level, confirms it, and applies the new depth."
+
+  - prompt: "¿En qué punto del proyecto vamos?"
+    why: "A 'where am I?' question — orient renders the map (what's built, what's missing, what phase)."
+
+  - prompt: "Acabo de terminar el spec. Listo."
+    why: "A turn ends after finishing work — orient must not end in seco; it proposes the next phase as a question."
+
+should_not_trigger:
+  - prompt: "Renombra esta variable a `userCount`."
+    route_to: "none"
+    why: "A trivial mechanical edit mid-flow — orient does not interrupt with a full brújula block over a one-line change."
+
+  - prompt: "Necesito una base de datos para guardar pedidos."
+    route_to: "suggest"
+    why: "This is an install gap — suggest owns it. orient must not duplicate the 'install it?' prompt."
+
+  - prompt: "Optimiza esta query de Postgres que va lenta."
+    route_to: "postgresdb"
+    why: "A concrete task owned by another skill; orient adds the closing block but does not drive the work."
+
+  - prompt: "Arregla el test que falla."
+    route_to: "debug"
+    why: "Root-cause work owned by debug; orient does not take over the task itself."
+
+capability:
+  - scenario: "The user just ran `npx rsc add postgresdb` and says 'ya está, ¿y ahora qué?'. The profile shows accompaniment_level L0. Show how orient closes the turn."
+    must_include:
+      - "Situates the user on the map ('📍 dónde estás' / what is built vs missing)"
+      - "States what just happened in one plain-language line ('✅ instalaste la base de datos')"
+      - "Proposes a concrete next step ending in a question, never leaving the turn in seco"
+      - "At L0, keeps it to ✅ + ➡️ with a single yes/no option and zero jargon"
+      - "Does NOT re-prompt to install a skill (defers that to suggest)"
+
+  - scenario: "Mid-project, the user says 'explícame menos'. The profile shows accompaniment_level L2. Show how orient responds."
+    must_include:
+      - "Updates accompaniment_level in 02-DOCS/wiki/harness/user-profile.md to a lower level"
+      - "Confirms the change in one line"
+      - "Re-renders guidance at the reduced depth from this turn on"
+      - "Still closes with a next-step question (no seco)"

package/skills/orient/references/orientation-contract.md

@@ -0,0 +1,34 @@
+# Orientation contract
+
+The single definition of how the harness keeps the user oriented. The `orient` skill owns
+it; other skills reference this file in a short footer instead of copying it.
+
+## The rule
+
+**No turn ends in seco (dead-end).** Every turn that finishes an action, reaches a fork, or
+could leave the user unsure closes with the brújula block.
+
+## The brújula block
+
+```
+📍 Dónde estás — the project phase/state (the map)
+✅ Qué acabas de hacer — one line, in the user's language
+🧭 Por qué — the technical why, scaled to the dial
+➡️ Siguiente — 1-3 concrete options, ending in a question. Never in seco.
+```
+
+## Calibration (the dial)
+
+Read `02-DOCS/wiki/harness/user-profile.md`. Two fields combine: `accompaniment_level` (L0 | L1 | L2 | L3) sets how deep the block goes; `technical_level` (non-technical | mixed | technical) sets the vocabulary.
+
+- **L0 — cavernícola:** only `✅` + `➡️`, one option, yes/no question.
+- **L1 — breve:** the four lines; one line of why.
+- **L2 — explica decisiones:** the four lines; justify the relevant decision; real forks.
+- **L3 — acompañamiento total:** the four lines, full why, many orienting questions, each option in plain language.
+
+`technical_level` is orthogonal (plain language for `non-technical` even at L0; skip 101s for `technical` even at L3). Missing profile → assume `non-technical` + **L3** and offer to set the dial.
+
+## Division of labor
+
+- `orient` guides the **person** (this contract).
+- `suggest` equips the **session** ("install the missing skill?"). Defer install prompts to it.