@dsalazardev/ai-hub-cli 0.0.0-stage → 0.2.0

package/skills/shared/fly-io/evals/cases.yaml

@@ -0,0 +1,42 @@
+skill: fly-io
+
+should_trigger:
+  - prompt: "Deploy my Dockerized API to Fly.io in Frankfurt and Virginia"
+    why: Core use — a multi-region Fly deploy with explicit region placement (fra + iad).
+  - prompt: "My fly.toml scales to zero but cold starts are slow, how do I keep one machine warm?"
+    why: Autostop tuning (min_machines_running tradeoff) — Fly-specific, not generic scaling theory.
+  - prompt: "Users in Sydney get high latency and my app only runs in iad"
+    why: Non-obvious — no 'Fly' keyword, but 'iad' region code + latency-by-distance is a Fly region-placement problem (add a Machine in syd).
+  - prompt: "Need to attach a persistent disk to my Fly machine for SQLite"
+    why: Fly Volumes — region/machine-pinned disk attached via [[mounts]].
+  - prompt: "Vull desplegar a Fly.io amb secrets i rèpliques per regió"
+    why: Catalan — deploy to Fly.io with secrets and per-region replicas; secrets + multi-region.
+  - prompt: "How do I forward writes to the primary region while reads stay local on Fly?"
+    why: Non-obvious — the fly-replay write-forwarding pattern for stateful multi-region.
+
+should_not_trigger:
+  - prompt: "Deploy my app to Railway with git push"
+    route_to: railway
+    why: Railway is a git-push PaaS with no Machines/regions model — different platform.
+  - prompt: "Host my Next.js site on the edge with a CDN"
+    route_to: vercel
+    why: Frontend/serverless edge hosting, not Fly Machines.
+  - prompt: "Write a multi-stage Dockerfile for my Go service"
+    route_to: docker
+    why: Image build mechanics — Fly consumes the Dockerfile but does not author it.
+  - prompt: "Design a load-shedding and queue strategy for traffic spikes"
+    route_to: scaling
+    why: Generic horizontal-scaling theory, platform-agnostic.
+
+capability:
+  - scenario: >
+      A single-region (iad) Express app talks to Postgres via DATABASE_URL. Make it
+      serve EU + US users and scale to zero outside business hours, keeping cold-start
+      pain in mind.
+    must_include:
+      - "fly.toml with primary_region = \"iad\" and an [http_service] with internal_port"
+      - "auto_stop_machines and auto_start_machines set together (not one alone)"
+      - "min_machines_running = 0 for scale-to-zero, with the cold-start tradeoff called out (set to 1 to keep one warm; honored only in primary region)"
+      - "fly scale count with --region to add an EU region (e.g. ams) for nearby users"
+      - "secrets via `fly secrets set DATABASE_URL=...`, never in [env]"
+      - "note that Fly Volumes/Postgres are region-pinned with no replication; cross-region writes need a replica + fly-replay or a managed/external DB"

package/skills/shared/fly-io/references/fly-toml.md

@@ -0,0 +1,155 @@
+# fly.toml field reference
+
+The full configuration surface. The SKILL.md body covers the common case; reach here for a key it did not show. Source: https://fly.io/docs/reference/configuration/ (accessed 2026-06-02).
+
+## Top level
+
+```toml
+app              = "my-api"      # required, unique app name
+primary_region   = "iad"        # 3-letter region code; the write/anchor region
+kill_signal      = "SIGINT"     # signal sent on shutdown
+kill_timeout     = "5s"         # grace period before SIGKILL
+swap_size_mb     = 512          # optional swap file (helps memory-spiky workloads)
+
+[experimental]
+  # rarely needed; flags for unreleased behavior
+```
+
+## [build]
+
+```toml
+[build]
+  dockerfile      = "Dockerfile"   # default if present
+  # builder        = "paketobuildpacks/builder:base"   # buildpack instead of Dockerfile
+  # image          = "flyio/myimage:latest"            # deploy a prebuilt image, skip build
+  [build.args]
+    NODE_VERSION = "22"
+```
+
+The image mechanics belong to ../docker/SKILL.md — Fly only consumes the build.
+
+## Services: [http_service] vs [[services]]
+
+`[http_service]` is the sugar for the common single HTTP service. Use `[[services]]` when you need raw TCP, multiple ports, or several services.
+
+```toml
+# Lower-level, explicit form
+[[services]]
+  internal_port = 8080
+  protocol      = "tcp"
+  processes     = ["web"]
+
+  [[services.ports]]
+    port     = 443
+    handlers = ["tls", "http"]
+  [[services.ports]]
+    port        = 80
+    handlers    = ["http"]
+    force_https = true
+
+  [services.concurrency]
+    type       = "requests"   # "requests" | "connections"
+    soft_limit = 200
+    hard_limit = 250
+
+  [[services.tcp_checks]]
+    interval = "15s"
+    timeout  = "2s"
+  [[services.http_checks]]
+    interval = "15s"
+    timeout  = "2s"
+    method   = "get"
+    path     = "/health"
+```
+
+`internal_port` is the port your process listens on inside the container. `handlers` tell the Proxy how to terminate (`tls`, `http`). Exactly one service should define the public HTTP entrypoint.
+
+## [[vm]]
+
+Formerly `[[compute]]`. Bind to process groups via `processes`.
+
+```toml
+[[vm]]
+  size       = "shared-cpu-1x"   # preset; sets cpus + memory together
+  memory     = "512mb"           # override the preset memory
+  cpu_kind   = "shared"          # "shared" | "performance"
+  cpus       = 1
+  processes  = ["web"]
+```
+
+Common sizes: `shared-cpu-1x/2x/4x/8x` (burstable), `performance-1x/2x/4x/8x` (dedicated). Memory presets scale with the size; override with `memory` for memory-heavy, low-CPU work.
+
+## [processes]
+
+```toml
+[processes]
+  web    = "node server.js"
+  worker = "node worker.js"
+```
+
+Each key is a process group running the same image with a different command. `[[vm]]`, `[http_service]`, `[[mounts]]`, and `[[services]]` all target groups via `processes`. A group with no service takes no inbound traffic.
+
+## [[mounts]]
+
+```toml
+[[mounts]]
+  source             = "data"     # volume name
+  destination        = "/data"    # mount path in the guest
+  processes          = ["web"]
+  initial_size       = "1gb"
+  snapshot_retention = 7          # days of automatic volume snapshots
+```
+
+One volume per Machine, region-pinned, no replication. See the SKILL.md Volumes section and `multi-region.md`.
+
+## [deploy]
+
+```toml
+[deploy]
+  release_command = "npm run migrate"   # one-shot Machine run before the rollout goes live
+  strategy        = "rolling"            # rolling | bluegreen | canary | immediate
+  max_unavailable = 0.33                 # fraction (or int) of Machines down at once during rolling
+```
+
+`release_command` runs in a temporary Machine with the new image + secrets; if it exits nonzero, the deploy aborts. Ideal for migrations.
+
+## [[statics]]
+
+Serve static assets directly from the Proxy / object storage instead of your process:
+
+```toml
+[[statics]]
+  guest_path = "/app/public"
+  url_prefix = "/static/"
+```
+
+## [[files]]
+
+Write files into the guest at boot — including secrets as files:
+
+```toml
+[[files]]
+  guest_path  = "/etc/app/config.yaml"
+  local_path  = "config/prod.yaml"     # ship a local file
+[[files]]
+  guest_path  = "/etc/app/sa.json"
+  secret_name = "GCP_SA_JSON"          # materialize a secret as a file
+[[files]]
+  guest_path  = "/etc/app/banner.txt"
+  raw_value   = "aGVsbG8="             # base64 inline content
+```
+
+Use `secret_name` for credentials a library expects on disk (e.g. a service-account JSON) rather than in an env var.
+
+## [restart] and [metrics]
+
+```toml
+[restart]
+  policy = "on-failure"   # "no" | "on-failure" | "always"
+
+[metrics]
+  port = 9091
+  path = "/metrics"       # Prometheus scrape endpoint Fly ingests
+```
+
+The `[metrics]` endpoint is what `fly-autoscaler` reads to scale by custom metrics (see `multi-region.md` / the SKILL.md scaling table).

package/skills/shared/fly-io/references/multi-region.md

@@ -0,0 +1,66 @@
+# Multi-region playbook
+
+Most deploys do not need this — run Machines in more regions and let anycast do the rest. Reach here when you have **state** that must stay correct across regions. Sources: https://fly.io/docs/networking/dynamic-request-routing/ , https://fly.io/docs/blueprints/multi-region-fly-replay/ , https://fly.io/docs/launch/scale-count/ (accessed 2026-06-02).
+
+## Decide the shape
+
+| Your state lives in... | Pattern |
+| --- | --- |
+| Nowhere local (DB is external/managed, app is stateless) | **Stateless replicate** — just add regions |
+| A Fly Volume / embedded DB (SQLite, LiteFS) | **Primary + read replicas** with `fly-replay` write forwarding |
+| Fly Postgres | One primary region; route writes there, reads to local replicas |
+
+## Stateless replicate
+
+The easy path. No volumes, no write coordination.
+
+```bash
+fly scale count 1 --region iad,ams,syd   # one Machine in each of three regions
+fly scale show
+```
+
+Anycast sends each caller to the nearest Machine. All Machines are identical and talk to the same external datastore. Done.
+
+## Primary + read replicas (fly-replay write forwarding)
+
+When reads can be local but **writes must hit one region** (the `primary_region`), use the `fly-replay` header. Replicas serve reads instantly; on a write, the app tells the Proxy to replay the entire request in the primary region.
+
+Header forms the app can return:
+
+```text
+fly-replay: region=iad        # replay this request in region iad
+fly-replay: instance=<id>      # replay on a specific Machine
+fly-replay: app=other-app      # replay against a different app
+fly-replay: elsewhere=true     # "not me" — let the Proxy pick another Machine
+```
+
+Sketch (Node/Express), forwarding writes to the primary region:
+
+```javascript
+const PRIMARY = process.env.PRIMARY_REGION;   // Fly injects PRIMARY_REGION
+const HERE    = process.env.FLY_REGION;       // and FLY_REGION for the current Machine
+
+app.use((req, res, next) => {
+  const isWrite = req.method !== "GET" && req.method !== "HEAD";
+  if (isWrite && HERE !== PRIMARY) {
+    res.set("fly-replay", `region=${PRIMARY}`);
+    return res.status(409).end();   // body is discarded; Proxy re-runs the request in PRIMARY
+  }
+  next();
+});
+```
+
+Why a status like 409: the response is never sent to the client — the Proxy intercepts the `fly-replay` header and re-runs the original request (method, path, body) in the target. Your replica code just needs to *refuse locally and tag it*.
+
+`PRIMARY_REGION` and `FLY_REGION` are environment variables Fly injects into every Machine — read them to know "am I the writer."
+
+## Volume strategy across regions
+
+- A volume is pinned to one Machine in one region; there is no cross-region replication.
+- For per-region read replicas, give **each region its own volume** and replicate at the application layer.
+- **LiteFS** is Fly's distributed SQLite layer: it ships the primary's writes to replica nodes and integrates with `fly-replay` so writes route to the primary automatically. Use it when you want SQLite semantics with multi-region reads.
+- For Postgres, run a primary in `primary_region` and read replicas elsewhere; send writes to the primary (via connection routing or `fly-replay`). Operating the engine itself belongs to ../postgresdb/SKILL.md.
+
+## Capacity caveat
+
+`fly scale count N --region a,b,c` places N Machines in **each** listed region. If **any** region is out of capacity the whole operation fails atomically — nothing is placed. Retry with fewer regions, a different code (`fly platform regions` for alternatives), or place granularly with `fly machine clone <id> --region <code>`.

package/skills/shared/fly-io/scripts/verify.sh

@@ -0,0 +1,90 @@
+#!/usr/bin/env bash
+# verify.sh — lint a fly.toml. Read-only. Exits 0 on a clean/empty target.
+#
+# Usage: scripts/verify.sh [path/to/fly.toml]   (defaults to ./fly.toml)
+#
+# Prefers `fly config validate` when flyctl is on PATH; otherwise runs
+# structural grep checks. Prints PASS:/FAIL: lines; nonzero exit on any FAIL.
+
+set -u
+
+TARGET="${1:-fly.toml}"
+fails=0
+
+pass() { printf 'PASS: %s\n' "$1"; }
+fail() { printf 'FAIL: %s\n' "$1"; fails=$((fails + 1)); }
+info() { printf 'INFO: %s\n' "$1"; }
+
+# Empty/clean target: nothing to lint, do not invent a failure.
+if [ ! -e "$TARGET" ]; then
+  info "no fly.toml at '$TARGET' — nothing to verify"
+  exit 0
+fi
+if [ ! -s "$TARGET" ]; then
+  info "'$TARGET' is empty — nothing to verify"
+  exit 0
+fi
+
+pass "found $TARGET"
+
+# Prefer the real validator when available.
+FLY_BIN=""
+if command -v fly >/dev/null 2>&1; then
+  FLY_BIN="fly"
+elif command -v flyctl >/dev/null 2>&1; then
+  FLY_BIN="flyctl"
+fi
+
+if [ -n "$FLY_BIN" ]; then
+  info "$FLY_BIN on PATH — running '$FLY_BIN config validate'"
+  if "$FLY_BIN" config validate --config "$TARGET" >/dev/null 2>&1; then
+    pass "$FLY_BIN config validate"
+  else
+    fail "$FLY_BIN config validate reported errors (run '$FLY_BIN config validate --config $TARGET')"
+  fi
+  [ "$fails" -eq 0 ] && exit 0 || exit 1
+fi
+
+info "flyctl not found — falling back to structural checks"
+
+# app = "..."
+if grep -Eq '^[[:space:]]*app[[:space:]]*=' "$TARGET"; then
+  pass "app is set"
+else
+  fail "missing top-level 'app ='"
+fi
+
+# primary_region = "..."
+if grep -Eq '^[[:space:]]*primary_region[[:space:]]*=' "$TARGET"; then
+  pass "primary_region is set"
+else
+  fail "missing 'primary_region ='"
+fi
+
+# an internal_port under [http_service] or [[services]]
+if grep -Eq '^[[:space:]]*internal_port[[:space:]]*=' "$TARGET"; then
+  pass "internal_port is defined"
+else
+  fail "no 'internal_port' found (expected under [http_service] or [[services]])"
+fi
+
+# autostop pair lint: if either key present, both must be present
+has_stop=0; has_start=0
+grep -Eq '^[[:space:]]*auto_stop_machines[[:space:]]*='  "$TARGET" && has_stop=1
+grep -Eq '^[[:space:]]*auto_start_machines[[:space:]]*=' "$TARGET" && has_start=1
+if [ "$has_stop" -eq 1 ] || [ "$has_start" -eq 1 ]; then
+  if [ "$has_stop" -eq 1 ] && [ "$has_start" -eq 1 ]; then
+    pass "auto_stop_machines and auto_start_machines set together"
+  else
+    fail "set auto_stop_machines and auto_start_machines together (only one is present)"
+  fi
+else
+  info "no autostop keys — skipping pair lint"
+fi
+
+if [ "$fails" -eq 0 ]; then
+  printf '\nOK: %s passed structural checks\n' "$TARGET"
+  exit 0
+fi
+printf '\n%d check(s) failed\n' "$fails"
+exit 1

package/skills/shared/ftd/SKILL.md

@@ -0,0 +1,111 @@
+---
+name: ftd
+description: "Use for ordinary authorised change — the default lane once the decisor has ruled out a question and not selected the chain. Keeps one feature document per feature in 02-DOCS holding intent, scope, checklist, evidence and next step, checks tasks off only against observed proof, and asks whether to branch before the work writes code. NOT the ten-phase chain (that is `sdd`), NOT the classification itself (that is the decisor in `suggest`), NOT a request for information, which writes nothing."
+tags: [ftd, lane, default, feature-document, evidence]
+recommends: [worktrees, debug, verify]
+profiles: [minimal, core, full]
+origin: ai-hub
+---
+
+# FTD — Fast-Track Development
+
+The lane ordinary work takes. Not a lighter methodology: the **same** discipline about evidence with
+none of the coordination the ten-phase chain exists to buy. One document instead of five, written
+because the work might be interrupted, not because somebody has to approve it first.
+
+You are here because the decisor in `../suggest/SKILL.md` ruled that this turn authorises a change
+and did not select `../sdd/SKILL.md`. If it is still a question, you are in the wrong place: go back
+and answer it.
+
+## Why this lane exists
+
+The constitution's seventh principle has said it from the start: *«la fricción es proporcional al
+riesgo. Silencio para lo trivial, ceremonia solo donde el fallo es caro. Un sistema que molesta en el
+80% inofensivo acaba apagado, y apagado no protege el 20% que importa.»*
+
+The harness spent a long time contradicting it — every request that sounded like building went
+through ten phases. This lane is that principle finally implemented, not a new idea.
+
+## The feature document
+
+One per feature, in the workspace wiki under `02-DOCS/wiki/ftd/<slug>.md`. **Never inside the code
+repository**: whoever clones it should get code, not somebody else's notes in progress.
+
+It is written **before the first change**, not after, and it holds exactly this:
+
+```markdown
+---
+author: <who asked for it — git user.name>
+branch: <the branch the work runs on>
+status: in-progress
+---
+# <feature>
+
+## Intent          — what changes, and why it is worth doing
+## Scope           — what is in, and what is explicitly not
+## Checklist       — one line per task, each with what would prove it done
+## Evidence        — the observed output per completed task
+## Next            — the single next step, so an interruption costs nothing
+```
+
+The frontmatter says whose work it is, so «¿qué ha hecho cada uno?» has an answer. You never close
+it by hand: when the branch lands on the default branch, ai-hub's post-merge hook sets `status: done`
+and replaces Next with where and when it merged (on a closed default branch, via `ai-hub/knowledge`).
+
+No decision journal, no phase records, no approvals. If a decision was meaningful, one line of
+rationale goes next to the task it belongs to.
+
+**The checkbox is not the proof.** A task is checked off when its stated check has been *observed* —
+the test output, the command's result, the page rendering. A task whose check was skipped, failed or
+could not run is recorded as such, honestly. The tenth principle applies here exactly as it does in
+the chain: a result asserted without evidence is treated as not done.
+
+## Isolation
+
+Where the work runs follows the project's decision (asked at install: «main» or «ramas y PR»; ai-hub
+says which on every turn) — never a branch opened on your own:
+
+- **Default branch open** (research, content, scripts, simple projects) → work straight on it. Do not
+  ask about branches.
+- **Default branch closed for the agent** (long-lived code: «ramas y PR» chosen at install, CI, a
+  deployment or several people) → before EACH change that writes code, ask in one line: «¿Lo hago en
+  esta rama (`<current>`), en una nueva, o desbloqueo `<default branch>`?». Already on another branch
+  is no exception: an unrelated change does not go into it without asking. A new branch is named by
+  intent and closes with a pull request. Unlocking is `ai-hub main unlock`; never without that answer.
+- **Docs, wiki or config only** → no question, no branch.
+- **Another session working in this same folder** → a worktree in `.worktrees/<branch>/`, never a
+  branch switch under the other session. Not a question: ai-hub tells you when that is the case.
+
+A worktree only when another session is there: alone, setting one up costs more than it protects.
+
+`../worktrees/SKILL.md` owns the isolation mechanics if you need them. Once the branch lands, the
+cleanup is automatic and you do not run anything.
+
+## Growing out of the lane
+
+A feature that turns out to need the chain is **promoted, not restarted**: the feature document
+becomes the input to `../specify/SKILL.md`, and no completed work is discarded. Promotion happens for
+the same reason the chain is ever entered — durable artifacts would remove a substantial ambiguity —
+and never because the work turned out to be big.
+
+## Anti-patterns → STOP
+
+| If you're about to… | Reality / Fix |
+| --- | --- |
+| Skip the document because the change is small | The document is what survives an interruption. Write it, keep it short. |
+| Check a task off because you believe it works | Observed proof or it is not done (P10). Record the check you could not run. |
+| Write the document into the code repository | It belongs in `02-DOCS`. A clone should get code, not notes. |
+| Open a worktree "to be safe" | That is the chain's ceremony arriving through the back door (P7). |
+| Escalate to the chain because the change is large | Size never selects it. Only unresolved ambiguity that artifacts would settle. |
+| Produce a spec, plan or task artifact here | Those are the chain's. This lane has one document. |
+
+## See Also
+
+- `../suggest/SKILL.md` — the decisor that routed here, and the other two lanes.
+- `../sdd/SKILL.md` — the ten-phase chain, for when artifacts genuinely earn their cost.
+- `../verify/SKILL.md` — the evidence gate, when this lane's checks need the full battery.
+- `../debug/SKILL.md` — a failure to reproduce before fixing; comes back here afterwards.
+
+## Orientación (siempre)
+
+Habla con la voz de `orient`: frases cortas, una idea por frase, y cada respuesta se entiende sola. Registro técnico o con analogías según `technical_level` en `02-DOCS/wiki/harness/user-profile.md`. Cierra cada turno con el **bloque-brújula** (📍 dónde estás · ➡️ siguiente, terminando en pregunta; ✅ y 🧭 cuando hay algo hecho o decidido). **Nunca termines en seco.** Protocolo completo: skill `orient` → `skills/orient/references/orientation-contract.md`. (Defiere a `suggest` el "¿instalo la skill que falta?".)

package/skills/shared/ftd/evals/cases.yaml

@@ -0,0 +1,66 @@
+skill: ftd
+
+# Cases for FTD — Fast-Track Development, the lane ordinary authorised change takes.
+# FTD keeps ONE feature document per feature in docs/ (intent, scope, checklist,
+# evidence, next step), checks tasks off only against observed proof, and branches when
+# the work writes code. It is NOT the ten-phase chain (sdd), NOT the classification
+# itself (the decisor lives in the always-on suggest body), and NOT a request for
+# information — those write nothing at all.
+
+should_trigger:
+  - prompt: "Añade exportación a CSV usando los filtros del informe que ya existen."
+    why: "An outcome asked for plainly: the change is authorised, understood, and no durable spec would settle anything the code does not. This is the default lane, entered without ceremony."
+
+  - prompt: "Rename the users table across every call site that touches it — there are about forty."
+    why: "Large and mechanical. Size is exactly what must NOT escalate to the chain; forty call sites carry no unresolved design question, so it stays here with one feature document."
+
+  - prompt: "Bump the dependency and fix whatever breaks."
+    why: "Authorised, open-ended in effort but not in intent. The feature document exists so an interruption mid-way costs nothing, which is the whole reason this lane writes one."
+
+  - prompt: "Migra los tres endpoints al nuevo formato de respuesta y deja constancia de lo que has comprobado."
+    why: "Multiple coordinated steps plus an explicit ask for evidence — the checklist-with-observed-proof shape this skill owns, without any phase handoffs."
+
+  - prompt: "Arregla el typo del botón de guardar."
+    why: "Trivial and authorised. Still this lane: the document is short, but the lane is the same, and the boundary is authorisation rather than size."
+
+should_not_trigger:
+  - prompt: "¿Por qué el login tarda tanto en producción?"
+    route_to: "debug"
+    why: "A question about a failure, with nothing authorising a change. Investigation writes nothing; if it becomes a fix, debug reproduces the cause first."
+
+  - prompt: "Compare Postgres and SQLite for this workload and recommend one."
+    route_to: "suggest"
+    why: "Information only. The decisor's read-only lane answers and creates no artifact — a recommendation is not permission to implement it."
+
+  - prompt: "No tengo claro si los permisos van por rol o por recurso, y afecta al esquema, a la API y a la UI."
+    route_to: "specify"
+    why: "A substantial unresolved ambiguity that durable spec/plan/tasks would settle. Several interlocking decisions: the agent enters the chain itself and says why (team-safe-default)."
+
+  - prompt: "Quiero especificar bien el sistema de permisos antes de tocar nada."
+    route_to: "specify"
+    why: "The chain requested by name. Explicit selection always wins over the decisor's default."
+
+  - prompt: "Revisa este diff y dime si tiene bugs."
+    route_to: "code-review"
+    why: "Reading a finished diff for defects is a review, not a change. Nothing here authorises writing, so no feature document is created."
+
+capability:
+  - scenario: "A developer whose profile says the register: technical says: 'Añade exportación a CSV usando los filtros del informe que ya existen.' Show how the lane runs from the first word to delivery."
+    must_include:
+      - "Names the lane out loud in one line before acting, as the decisor requires — this is FTD, not a question and not the chain"
+      - "Creates one feature document at docs/ftd/<slug>.md BEFORE the first change, and says which document it created and how many tasks it holds"
+      - "Writes the document into the workspace wiki, never into the code repository, so whoever clones the repo gets code and not somebody's notes in progress"
+      - "Keeps the document to intent, scope, checklist, evidence and next step — no spec, no plan, no tasks artifact, no decision journal"
+      - "States for each checklist item what would prove it done, before doing it"
+      - "Opens a branch because the work writes code, and explicitly does NOT open a worktree"
+      - "Checks a task off only after observing its stated check, and records a check that failed, was skipped or could not run rather than omitting it (P10)"
+      - "Does not escalate to the ten-phase chain on the basis of size, file count or perceived risk"
+      - "Closes by reporting the verified outcome, every failed or pending check, and the single next step"
+
+  - scenario: "Mid-way through the same work, the developer says the requirement has changed: the export must also respect a date range that does not exist in the current filters. Show how the lane absorbs it."
+    must_include:
+      - "Revises the existing feature document rather than starting a second one, preserving completed work that is still valid"
+      - "Adds the genuinely new tasks, and reopens any invalidated task with the reason written next to it"
+      - "Distinguishes a change the user authorised from a finding the agent made — a finding alone never expands scope"
+      - "Considers promotion to the chain only if durable artifacts would settle a substantial ambiguity, and says so rather than escalating because the work grew"
+      - "If promoted, carries the feature document into specify as input instead of discarding the work already done"

package/skills/shared/ftd/evals/routing.json

@@ -0,0 +1,24 @@
+{
+  "about": "Fixture corpus for the three-lane decisor. The decisor is prose and judgement — chosen deliberately over deterministic signals — so this corpus is the mechanism that makes it checkable (P2). Scored by the behaviour eval, not by npm test; what npm test checks is that the corpus stays honest: every lane represented, every case reasoned, and the cases this lane exists because of still present.",
+  "lanes": {
+    "answer": "information only; writes nothing, creates no artifact",
+    "ftd": "authorised change, ordinary; one feature document",
+    "sdd": "the ten-phase chain, entered by the agent for big or complex work"
+  },
+  "cases": [
+    { "request": "¿Por qué el login tarda tanto en producción?", "expect": "answer", "why": "investigation; nothing authorises a change" },
+    { "request": "Compare Postgres and SQLite for this workload and recommend one", "expect": "answer", "why": "comparison and a recommendation are information, not a mandate" },
+    { "request": "Revisa este diff y dime si tiene bugs", "expect": "answer", "why": "review is read-only even though it is about code that changes" },
+    { "request": "Audita la seguridad de la capa de autenticación", "expect": "answer", "why": "audit; a finding is not permission to fix it" },
+    { "request": "¿Y si añadiéramos exportación a CSV?", "expect": "answer", "why": "thinking aloud about a feature is not a request to build it; ask before building" },
+    { "request": "Propón cómo estructurarías el módulo de pagos", "expect": "answer", "why": "proposal-only; the old gate would have started the chain here" },
+    { "request": "Añade exportación a CSV usando los filtros del informe que ya existen", "expect": "ftd", "why": "an outcome asked for plainly: authorised, understood, no ambiguity artifacts would settle" },
+    { "request": "Arregla el typo del botón de guardar", "expect": "ftd", "why": "trivial and authorised; one document, no ceremony" },
+    { "request": "Renombra la tabla de usuarios en las 40 llamadas que la usan", "expect": "ftd", "why": "large and mechanical: size alone must never select the chain" },
+    { "request": "Sube la versión de la dependencia y arregla lo que rompa", "expect": "ftd", "why": "authorised change with no unresolved design question" },
+    { "request": "Migra los tres endpoints al nuevo formato de respuesta", "expect": "ftd", "why": "many files, but nothing a spec would settle that the code does not" },
+    { "request": "Quiero especificar bien el sistema de permisos antes de tocar nada", "expect": "sdd", "why": "explicit request for the chain" },
+    { "request": "Vamos a hacer una spec de esto", "expect": "sdd", "why": "explicit request, stated in the user's own words" },
+    { "request": "No tengo claro si los permisos van por rol o por recurso, y afecta al esquema, a la API y a la UI", "expect": "sdd", "why": "enter the chain: several interlocking decisions that durable artifacts would settle; the agent enters it and says why" }
+  ]
+}