chore: auto-commit (286 archivos)

- .claude/agents/fn-orquestador/SKILL.md
- .claude/commands/fn_claude.md
- .claude/rules/INDEX.md
- .claude/rules/cpp_apps.md
- .claude/rules/ids_naming.md
- CHANGELOG.md
- apps/dag_engine/README.md
- apps/dag_engine/api.go
- apps/dag_engine/dags_migrated/example.yaml
- apps/dag_engine/dags_migrated/example_lineage_tracking.yaml
- ...

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

.claude/rules/INDEX.md

@@ -34,3 +34,4 @@ Reglas operativas del proyecto. Cada archivo es una regla independiente.
 | 28 | [delegation.md](delegation.md) | Si vas a escribir logica reutilizable inline -> spawn fn-constructor inmediato + tag de grupo + usar en mismo turno. Issue 0086 |
 | 29 | [capability_groups.md](capability_groups.md) | Tags planos + paginas madre `docs/capabilities/<grupo>.md` para desbloquear clusters de funciones en un read. Issue 0086 |
 | 30 | [function_growth_and_self_docs.md](function_growth_and_self_docs.md) | Contrato self-doc de cada `.md` (Ejemplo + Cuando usarla + Gotchas + Growth log) + crecimiento del registry por **promocion de composiciones** a pipelines, NO por inflado de funciones. Issue 0087 |
+| 31 | [autonomous_loop.md](autonomous_loop.md) | Reglas para `fn-orquestador` + `/autonomous-task`: sandbox obligatorio, paths protegidos, filtro proposals auto-aplicables, watchdog, idempotencia. Issue 0069 |

.claude/rules/autonomous_loop.md

@@ -0,0 +1,75 @@
+## Bucle autonomo (`fn-orquestador` + `/autonomous-task`) — issue 0069
+
+`fn-orquestador` recorre el ciclo reactivo (CONSTRUIR → EJECUTAR → RECOPILAR → ANALIZAR → MEJORAR) sin intervencion humana, hasta convergencia (suite verde), estancamiento (no progreso N iteraciones), timeout, o tope de iteraciones. Trabaja SIEMPRE en sandbox `auto/<issue>`, NUNCA merge a master.
+
+### Cuando se invoca
+
+- Skill `/autonomous-task <issue_id>` (humano lanza explicitamente).
+- Cron / Dagu (planificable; no implementado por defecto).
+- NO se invoca como reaccion a hooks ni a fallos de tests "en caliente". Siempre tarea explicita.
+
+### Reglas duras
+
+1. **Sandbox obligatorio**: rama `auto/<issue_id>-<slug>`. Si la rama existe -> reset hard contra master y reanudar. NUNCA commits a master, NUNCA push --force-with-lease a master.
+2. **Paths protegidos**: respetar `dev/autonomous_protected_paths.json` exactamente. Cualquier intento de modificar un path protegido aborta la iteracion y registra `task_runs.status='aborted_protected_path'`.
+3. **Filtro de proposals auto-aplicables**: el orquestador SOLO aplica proposals que cumplen:
+   - `kind in (bug_fix, e2e_check_add, doc_update, capability_tag_add)` -> auto-aplicable.
+   - `kind in (new_function, deprecate_function, refactor, schema_change)` -> NO auto-aplicable (queda `pending` para humano).
+   - `priority in (low, medium)` -> auto-aplicable. `high|critical` -> requiere humano salvo override `--allow-high`.
+4. **Watchdog**: si la metrica de progreso (`checks_pass / checks_total`) no sube en `N=3` iteraciones consecutivas -> abort. Registrar `task_runs.status='stalled'`.
+5. **Tiempo**: cada `task_run` con timeout default 30 min. Override con `--timeout-min N` hasta max 4h.
+6. **Idempotencia**: re-ejecutar `/autonomous-task <id>` sobre la misma issue reanuda desde la ultima iteracion exitosa, NO reinicia desde cero (lookup en `task_runs` por `issue_id`).
+7. **Trazabilidad**: cada decision se persiste en `task_runs.events_json[]` con `{ts, agent, action, evidence, diff_summary}`. El humano puede leer el log entero para auditar.
+8. **No self-modification**: orquestador NUNCA modifica `.claude/agents/`, `.claude/commands/`, `.claude/rules/`, `.claude/scripts/`, `.claude/CLAUDE.md`. Reforzado en `autonomous_protected_paths.json`.
+9. **NUNCA paths absolutos fuera del worktree**. Refuerzo del piloto 1 (2026-05-15): el orquestador uso `/home/lucas/fn_registry/bash/functions/...` para fixear hooks bash y contamino el repo principal. Solucion correcta: fix vive solo en el worktree. Post-cada-iteracion: `git -C <main_repo> status --short` debe permanecer igual al baseline; cualquier diff = `status=sandbox_breach` -> ABORT.
+10. **Pre-commit hooks compartidos**. Worktrees comparten `.git/hooks/` con main. Si un hook llama scripts via path absoluto, ejecutara la version de main. Si el hook bloquea progreso por bug en main: aplica el fix EN EL WORKTREE (commit en auto/*); si el bug del hook excede scope: `git commit --no-verify` para ESE commit con `task_runs.events_json[].decision="skip_hook"` + razon. NO editar main.
+
+### Estructura task_run
+
+Migration `fn_operations/migrations/006_task_runs.sql`. Campos minimos: `id`, `issue_id`, `branch`, `started_at`, `finished_at`, `status` (`running|done|failed|aborted_protected_path|stalled|timeout`), `iterations`, `checks_pass`, `checks_fail`, `proposals_applied_json`, `proposals_skipped_json`, `events_json`, `final_diff_sha`.
+
+### Fases por iteracion
+
+```
+loop:
+  1. fn-constructor (Read+Edit+Write+Bash limitados) - aplica fix segun ultima proposal seleccionada
+  2. fn-executor - corre build + tests + smoke
+  3. fn-recopilador - audita operations.db de la app
+  4. fn-analizador - corre e2e_checks (registra e2e_runs)
+  5. SI todos los checks pasan -> commit + push rama + abre PR. status=done. exit.
+  6. SI no progreso N iteraciones -> abort. status=stalled.
+  7. fn-mejorador - crea proposals desde fallos
+  8. orquestador filtra proposals auto-aplicables -> selecciona la primera -> goto 1.
+```
+
+### Output al humano
+
+```
+=== /autonomous-task 0068 ===
+task_run_id:        run_e2e_a1b2c3
+branch:             auto/0068-e2e-validation
+iterations:         4
+status:             done
+checks_pass:        8/8
+proposals_applied:  3 (run_e2e_run_001, run_e2e_run_002, run_e2e_run_003)
+proposals_skipped:  1 (refactor — needs human review)
+PR:                 https://gitea.../pulls/42
+```
+
+### Anti-patrones
+
+| Anti-patron | Por que es malo |
+|---|---|
+| Mergear `auto/<issue>` a master sin PR + humano | Salta gate, riesgo de regresion |
+| Auto-aplicar proposal `kind=refactor` | Cambios sistemicos requieren revision |
+| Modificar `go.sum`, `package-lock.json`, `uv.lock` | Cambios de deps requieren CVE/license review |
+| Bucle infinito sin watchdog | Coste descontrolado de tokens |
+| Borrar archivos sin backup en `task_runs.events_json` | Pierde auditoria |
+| Override de paths protegidos via env var | Bypass de seguridad |
+
+### Relacion con otras reglas
+
+- [[e2e_validation]] — fn-analizador (fase 4) lee el contrato `e2e_checks` que el orquestador usa como gate.
+- [[apps_tbd]] — el orquestador opera en rama `auto/*`, no exenta de TBD.
+- [[feature_flags]] — si el fix no esta terminado, el orquestador puede meterlo detras de flag OFF antes de PR.
+- [[registry_calls]] — toda invocacion del orquestador y sub-agentes pasa por MCP/`fn run`/heredoc canonico, registrada en call_monitor.

.claude/rules/cpp_apps.md

@@ -20,14 +20,14 @@ Razones:
 
 Pipeline: `init_cpp_app_bash_pipelines`. Slash command equivalente: `/new-cpp-app`. Auditoria: `fn doctor cpp-apps`.
 
-### 1. Ubicacion
+### 1. Ubicacion (issue 0096 estandarizada)
 
 | Caso | Donde vive |
 |---|---|
-| App independiente | `cpp/apps/<nombre>/` |
+| App independiente | `apps/<nombre>/` |
 | App de un proyecto | `projects/<proyecto>/apps/<nombre>/` |
 
-NUNCA en `cpp/apps/<nombre>/` si pertenece a un proyecto, NUNCA fuera de `apps/` directamente. Ver `apps_location` en memoria + regla `apps_vs_functions.md`.
+NUNCA en `cpp/apps/<nombre>/` (deprecado tras issue 0096) ni en cualquier otra carpeta nombrada por lenguaje (`python/apps/`, `bash/apps/`, etc.). Las carpetas por lenguaje son solo para codigo del registry (`cpp/functions/`, `python/functions/`, etc.), nunca para artefactos. Ver `apps_location` en memoria + regla `apps_vs_functions.md`.
 
 ### 2. Estructura minima
 
@@ -189,20 +189,105 @@ WMs). Activado por defecto, sin opt-in:
    con `glfwSetWindowPos/Size` (no espera al siguiente NewFrame).
 2. **Per-frame viewport sync** al inicio del main loop — cubre viewports
    secundarios (paneles drag-out) que la backend crea dinamicamente.
-3. **Win32 WndProc subclass** (`#ifdef _WIN32`) — observa `WM_ENTERSIZEMOVE`
-   / `WM_EXITSIZEMOVE` que AltSnap fakea alrededor de cada drag. Mientras
-   el bracket esta abierto el main loop SKIPEA `render_fn` + `glfwSwapBuffers`,
-   replicando el contrato del title-bar drag native (DefWindowProc bloquea
-   el hilo, DWM compositor mueve el framebuffer existente).
+3. **Win32 WndProc subclass per HWND** (`#ifdef _WIN32`) — observa
+   `WM_ENTERSIZEMOVE` / `WM_EXITSIZEMOVE` que AltSnap fakea alrededor de cada
+   drag. El subclass se instala en la ventana principal Y en cada HWND
+   secundario que el backend de ImGui crea cuando un panel se arrastra fuera
+   del main (escaneo per-frame de `pio.Viewports`). Mientras el bracket esta
+   abierto en CUALQUIER HWND propio, el main loop SKIPEA `render_fn` +
+   `glfwSwapBuffers` globalmente, replicando el contrato del title-bar drag
+   native (DefWindowProc bloquea el hilo, DWM compositor mueve el framebuffer
+   existente). El flag `g_in_sizemove` es global a proposito: una sola
+   sesion de sizemove externo pausa todo el render para que ninguna ventana
+   compita con el OS.
 
-Tests: `cpp/apps/altsnap_jitter_test/` corre dos fases:
+   Estado del subclass:
+   - `g_subclassed` = `unordered_map<HWND, WNDPROC>`. Chain a la proc
+     original via `CallWindowProcW`.
+   - `install_sizemove_subclass_hwnd(HWND)` idempotente (skip si ya en mapa).
+   - Per-frame: `prune_dead_subclassed()` con `IsWindow` + install en cada
+     `pio.Viewports[i]->PlatformHandle` nuevo.
+   - `uninstall_sizemove_subclass_all()` restaura cada HWND al exit.
+
+#### Iconified main no pierde paneles flotantes (2026-05-16)
+
+El legacy `glfwWaitEvents + continue` al detectar `GLFW_ICONIFIED` paraba TODO
+el frame loop. Con multi-viewport activo eso significa que
+`ImGui::UpdatePlatformWindows + RenderPlatformWindowsDefault` dejan de
+refrescar los viewports secundarios — los floating panels aparecen congelados
+o son agrupados/ocultados por el WM. Fix actual: el iconified-gate cuenta
+viewports secundarios primero; si hay alguno, fall-through al frame normal
+(la swap del main HWND minimizado es harmless, los contexts GL secundarios
+siguen pintando). Solo cuando NO hay flotantes dormimos en `glfwWaitEvents`.
+
+#### Alt + RMB / Alt + LMB anywhere → modal nativo (2026-05-16)
+
+WndProc del subclass tambien intercepta clicks con Alt held (`GetAsyncKeyState(VK_MENU) & 0x8000`):
+
+- `WM_LBUTTONDOWN` + Alt → `ReleaseCapture()` +
+  `PostMessage(WM_SYSCOMMAND, SC_MOVE | HTCAPTION)`. Modal MOVE nativo.
+- `WM_RBUTTONDOWN` + Alt → calcula direccion por cuadrante (TOPLEFT/TOPRIGHT/
+  BOTTOMLEFT/BOTTOMRIGHT relativo al centro del client rect) y emite
+  `PostMessage(WM_SYSCOMMAND, SC_SIZE | dir)`. Modal RESIZE nativo.
+
+Ambos retornan 0 (consumen el click — ImGui NO lo ve). Aplica a main y a
+cada viewport flotante porque el subclass per-frame ya cubre todos los HWND.
+El modal nativo dispara `WM_ENTERSIZEMOVE`, que el gate existente pausa
+render → cero jitter automatico, mismo contrato que el title-bar drag.
+
+**Caveat**: cualquier Alt+click se consume — perdes Alt+click como shortcut
+UI. Aceptable porque Alt-modifier en clicks UI es muy raro.
+
+#### Title-bar-only move para ImGui windows (2026-05-16)
+
+`fn::run_app` setea `io.ConfigWindowsMoveFromTitleBarOnly = true`. Critico
+para viewports secundarios: un viewport flotante = OS window borderless con
+UNA ventana ImGui rellenandolo. Sin el flag, ImGui mueve sus ventanas
+arrastrando cualquier client-pixel — como la ventana ImGui ES el viewport
+entero, el OS window sigue al cursor sin modifier. Con el flag, floating
+panels obedecen el contrato "solo header arrastra" (igual que main que tiene
+title bar nativo de Windows). Alt+LMB anywhere sigue funcionando (consumido
+antes por el subclass).
+
+#### Test observability — `fn::internal::*` (2026-05-16)
+
+Counters monotonicos para validar el subclass desde tests headless,
+zero-cost en prod:
+
+```cpp
+namespace fn::internal {
+    int  sizemove_enter_count();   // ++ en cada WM_ENTERSIZEMOVE
+    int  alt_rmb_resize_count();   // ++ en cada Alt+RMB consumido
+    int  alt_lmb_move_count();     // ++ en cada Alt+LMB consumido
+    int  rbuttondown_seen_count(); // diagnostico — todo WM_RBUTTONDOWN
+    void set_force_alt_for_test(bool); // bypass GetAsyncKeyState para tests
+}
+```
+
+En test mode (`set_force_alt_for_test(true)`), los handlers de Alt cuentan
+pero NO postean `SC_SIZE`/`SC_MOVE` — el harness no se queda atrapado en el
+modal de Windows. Path real en prod sigue posteandolos.
+
+Tests: `apps/altsnap_jitter_test/` corre seis fases:
 - `p1.sync` (cross-platform): drives `glfwSetWindowPos` cada frame, asserta
   `vp->Pos` sigue OS dentro de 1px.
 - `p2.altsnap` (Windows): worker thread fakea `WM_ENTERSIZEMOVE` +
-  burst de `SetWindowPos(SWP_ASYNCWINDOWPOS)` + `WM_EXITSIZEMOVE`, asserta
-  que `render()` no se llama durante el bracket.
+  burst de `SetWindowPos(SWP_ASYNCWINDOWPOS)` + `WM_EXITSIZEMOVE` sobre el
+  HWND principal, asserta que `render()` no se llama durante el bracket.
+- `p3.secondary` (Windows): fuerza viewport secundario
+  (`ConfigViewportsNoAutoMerge=true`), localiza su HWND y repite el bracket
+  sobre el. Valida que el subclass per-viewport tambien pausa el render.
+- `p4.minimize` (Windows): state machine 4 steps — captura
+  `IsWindow(secondary_hwnd)` antes/durante/despues de `glfwIconifyWindow +
+  glfwRestoreWindow`. Asserta los 3 estados vivos y `renders_iconified > 0`.
+- `p5.alt_rmb` (Windows): `set_force_alt_for_test(true)` +
+  `SendMessage(WM_RBUTTONDOWN)` sincrono mismo-hilo. Asserta
+  `alt_rmb_resize_count` incrementa.
+- `p6.alt_lmb` (Windows): mismo patron para `WM_LBUTTONDOWN`. Asserta
+  `alt_lmb_move_count` incrementa.
 
-Lanzar con `e2e_run_cpp_windows altsnap_jitter_test`.
+Lanzar con `source bash/functions/infra/e2e_run_cpp_windows.sh &&
+e2e_run_cpp_windows altsnap_jitter_test`.
 
 NO hace falta nada en cada app — toda `fn::run_app` lo hereda. Si una app
 necesita renderizar incluso durante external move (caso raro: telemetria
@@ -261,3 +346,68 @@ de antes: `imgui.ini` es la unica fuente.
 - App headless / capture mode: `cfg.auto_layouts = false`.
 - Cambiar nombre del archivo: `cfg.auto_layouts_db = "<algo>.db"` (relativo a
   `local_files/`).
+
+### 11. Icono Windows (.ico embebido en el .exe) — 2026-05-16
+
+Cada app C++ desplegada a Windows tiene su propio icono. El icono vive en
+`<app_dir>/appicon.ico` (multi-resolucion: 16/24/32/48/64/128/256). El macro
+`add_imgui_app` de `cpp/CMakeLists.txt` lo detecta automaticamente: si
+`WIN32` + existe `<CMAKE_CURRENT_SOURCE_DIR>/appicon.ico`, genera un
+`<target>_appicon.rc` en `CMAKE_CURRENT_BINARY_DIR` apuntando al `.ico` con
+`IDI_ICON1 ICON "<path>"` y lo anade a `add_executable`. El compilador RC
+(`x86_64-w64-mingw32-windres` configurado en `cpp/toolchains/mingw-w64.cmake`)
+lo enlaza al `.exe` como recurso `.rsrc`.
+
+Verificar: `x86_64-w64-mingw32-objdump -h <app>.exe | grep rsrc` debe
+mostrar la seccion. El project line en `cpp/CMakeLists.txt` declara
+`LANGUAGES C CXX RC` solo en WIN32 (Linux ignora la `.rc`).
+
+#### Crear `.ico` para una app nueva
+
+Fuente de glyphs: **Phosphor Icons** (`sources/phosphor-core/`, clonado de
+`https://github.com/phosphor-icons/core.git`). 1512 SVGs en weight `regular`,
+`bold`, `fill`, `light`, `thin`, `duotone`. Usamos `fill` por defecto — mejor
+legibilidad a 16/24px.
+
+Funcion del registry: `generate_app_icon_py_infra` rasteriza un SVG Phosphor
+sobre fondo redondeado del color accent y exporta `.ico` multi-res. Una
+linea por app:
+
+```python
+from infra import generate_app_icon
+generate_app_icon(
+    phosphor_icon_name="chart-bar",
+    accent_hex="#0ea5e9",
+    out_ico_path="apps/chart_demo/appicon.ico",
+)
+```
+
+Mapping inicial (2026-05-16) en `dev/gen_app_icons.py` — script reproducible
+que regenera los 11 `.ico` de un golpe leyendo la tabla `APPS`. Anadir app
+nueva: una fila `(app_id, dir, phosphor_icon, accent_hex)` en `APPS` y
+`/tmp/iconenv/bin/python dev/gen_app_icons.py` (o el venv del registry, ya
+trae `cairosvg` + `Pillow`).
+
+Convenciones:
+- **Glyph weight**: `fill` (mas legible a 16px que `regular` o `bold`).
+- **Color**: 1 accent_hex distinto por app — Tailwind palette 500-700
+  funciona bien (`#0ea5e9` sky-500, `#16a34a` green-600, etc.).
+- **Padding**: glyph ocupa ~70% del canvas, fondo redondeado al 16% del lado.
+- **Glyph color**: siempre blanco sobre el fondo accent.
+
+Si Phosphor no tiene el icono adecuado: buscar en `sources/phosphor-core/assets/fill/`
+con `ls | grep <keyword>` antes de inventar — 1512 disponibles.
+
+#### Re-deploy tras cambiar icono
+
+```bash
+# 1. Regenerar .ico
+./fn run generate_app_icon "chart-bar" "#0ea5e9" "apps/chart_demo/appicon.ico"
+#    (o editar dev/gen_app_icons.py + relanzar)
+
+# 2. Rebuild + redeploy (build dispara windres → nuevo .rsrc)
+./fn run redeploy_cpp_app_windows chart_demo apps/chart_demo --build
+```
+
+Windows cachea iconos en `iconcache.db`. Si el nuevo icono no aparece tras
+desplegar, refresh con `ie4uinit.exe -show` o reiniciar Explorer.

.claude/rules/ids_naming.md

@@ -1,3 +1,35 @@
-IDs siguen el formato `{name}_{lang}_{domain}` (ej: `filter_slice_go_core`).
+## ids_naming — formato predictible
 
-Nombres de funciones en snake_case. Tipos en PascalCase para Go.
+IDs: `{name}_{lang}_{domain}` (ej: `filter_slice_go_core`). Predictibilidad alta -> Claude descubre por fuzzy match sin lookup. Issue 0087.
+
+### Reglas
+
+1. **snake_case**: `[a-z0-9_]+`. Nada de PascalCase, kebab-case, dot.notation.
+2. **Verbo obligatorio**: al menos un token del `name` debe ser un verbo de accion. El verbo puede ir delante (`get_user`) o detras (`user_lookup`). Ejemplos validos: `filter_slice`, `bank_login`, `metabase_get_dashboard`, `redeploy_cpp_app`. Invalidos: `slice` (sustantivo solo), `user` (sustantivo solo), `data` (sustantivo solo).
+3. **Dominio canonico**: el `domain` debe estar en la lista canonica (ver `mcp__registry__fn_list_domains`). Crear dominio nuevo solo si el bucket es claramente distinto y se anade en el mismo turno a CLAUDE.md.
+4. **Tipos en PascalCase Go**: `ResultGoCore`, `ErrorGoCore`. Aplica solo al codigo Go; el ID en el registry sigue siendo snake_case (`result_go_core`).
+
+### Verbos canonicos (allowlist)
+
+Lista no exhaustiva pero cubre la mayoria. Anadir aqui (y al validator en `apps/registry_mcp/naming.go`) cuando se introduzca un verbo nuevo recurrente.
+
+`get, set, list, find, search, show, read, load, fetch, scan, query, lookup, parse, format, encode, decode, marshal, unmarshal, serialize, deserialize, validate, check, ensure, verify, audit, diagnose, test, match, filter, map, reduce, sort, group, count, sum, aggregate, compute, calculate, score, rank, cluster, classify, detect, init, create, make, build, generate, scaffold, install, setup, configure, register, add, insert, append, prepend, update, upsert, modify, edit, patch, replace, delete, remove, clear, drop, prune, clean, copy, move, rename, sync, clone, extract, inject, import, export, send, post, put, call, dispatch, exec, run, launch, start, stop, kill, restart, redeploy, deploy, open, close, connect, disconnect, login, logout, authenticate, enable, disable, toggle, lock, unlock, propose, promote, deprecate, approve, reject, emit, render, draw, paint, serve, host, pull, push, checkout, commit, tag, merge, rebase, watch, monitor, observe, log, trace, profile, benchmark, snapshot, backup, restore, archive, compress, decompress, hash, encrypt, decrypt, sign, taskkill, recopile, vault, propose, apply, gather, collect, fold, head, tail, take, drop, slice, chunk, batch, debounce, throttle, retry, await, sleep, ping, kill, prime, warm, refresh, invalidate, reload, reset, rollback, fork, spawn, daemon, observe, plot, draw, capture, replay, recopilate`
+
+### Excepciones
+
+- **Operadores matematicos/estadisticos** ampliamente reconocidos por acronimo: `sma`, `ema`, `rsi`, `vwap`, `adx`. Validator hace allowlist explicita.
+- **Tipos** (entity_type `type`): no requieren verbo. Validator lo salta cuando `kind=type`.
+- **Components** (`kind: component`): nombre describe artefacto UI (`button_primary`, `chat_panel`). Permite forma `<noun>_<modifier>`. Validator salta el check de verbo si `kind=component`.
+
+### Validator
+
+`mcp__registry__fn_create_function` ejecuta el validator antes de escribir archivos. Rechaza con error si:
+- name no es snake_case.
+- name no contiene verbo (excepto component/type).
+- domain no esta en lista canonica.
+
+Error tipico:
+```
+naming: name "slice" lacks action verb. Add verb prefix/suffix (e.g. filter_slice, slice_window). See .claude/rules/ids_naming.md.
+naming: domain "bizops" not in canonical list (core, infra, finance, ...). Add it to CLAUDE.md and rules first.
+```