onesensei 0.2.0__tar.gz

onesensei-0.2.0/.claude/settings.json

@@ -0,0 +1,5 @@
+{
+  "enabledPlugins": {
+    "frontend-design@claude-plugins-official": true
+  }
+}

onesensei-0.2.0/.github/workflows/release.yml

@@ -0,0 +1,60 @@
+name: Build & Release
+
+on:
+  push:
+    tags:
+      - "v*"
+
+jobs:
+  build-macos:
+    name: macOS (arm64 + x86_64)
+    runs-on: macos-14        # Apple Silicon; compila universal si se quiere
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+
+      - name: Instalar dependencias de build
+        run: pip install pyinstaller hatchling
+
+      - name: Build binario
+        run: pyinstaller sensei.spec
+
+      - name: Renombrar con plataforma
+        run: mv dist/sensei dist/sensei-macos-arm64
+
+      - name: Crear release y subir asset
+        uses: softprops/action-gh-release@v2
+        with:
+          files: dist/sensei-macos-arm64
+          generate_release_notes: true
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+  build-macos-x86:
+    name: macOS (Intel x86_64)
+    runs-on: macos-13
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+
+      - name: Instalar dependencias de build
+        run: pip install pyinstaller hatchling
+
+      - name: Build binario
+        run: pyinstaller sensei.spec
+
+      - name: Renombrar con plataforma
+        run: mv dist/sensei dist/sensei-macos-x86_64
+
+      - name: Subir a release existente
+        uses: softprops/action-gh-release@v2
+        with:
+          files: dist/sensei-macos-x86_64
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

onesensei-0.2.0/.gitignore

@@ -0,0 +1,15 @@
+__pycache__/
+*.pyc
+dist/
+build/
+*.egg-info/
+.venv/
+.pytest_cache/
+.atlas/
+.claude/settings.local.json
+.superpowers/brainstorm/
+graphify-out/
+dojo/dojo.db
+dojo/*.db
+dojo/.env
+.worktrees/

onesensei-0.2.0/.graphifyignore

@@ -0,0 +1,7 @@
+.superpowers/
+.claude/
+docs/superpowers/
+graphify-out/
+.env
+.env.*
+.venv/

onesensei-0.2.0/.superpowers/sdd/.gitignore

@@ -0,0 +1 @@
+*

onesensei-0.2.0/.superpowers/sdd/final-review-fix-report.md

@@ -0,0 +1,106 @@
+# Final review fix report — cmd_costo (by_work_item honesty + --export/--merge conflict)
+
+## Contexto
+
+Dos hallazgos "Important" de la revisión final de todo el branch sobre código ya mergeado
+(`sensei/cli.py`, `cmd_costo`, HEAD `c2a821c` en `sensei/v2`).
+
+## Fix 1 — `by_work_item` es un no-op silencioso → ahora es honesto
+
+`by_work_item` se aceptaba y pasaba desde `main()` pero nunca se leía en el cuerpo de
+`cmd_costo`: la tabla por work item se mostraba siempre, con o sin `--by-work-item`.
+No se cambió el comportamiento (agregar gating real ahora sería prematuro — YAGNI, no
+existe una segunda vista todavía) ni la firma de la función (otros callers/tests la
+invocan con `by_work_item=True/False` explícito).
+
+Cambios:
+- Comentario agregado en `sensei/cli.py` justo antes de `rows = costo.by_work_item(payload)`
+  explicando por qué el parámetro no gatea nada hoy y cuándo empezará a importar.
+- `help=` de `--by-work-item` en `main()` reescrito para no insinuar que el flag es
+  necesario u que cambia el comportamiento: ahora dice explícitamente que agrupar por
+  work item es el comportamiento por defecto hoy y que el flag existe por compatibilidad
+  con el roadmap (`docs/ROADMAP_SPEC.md`).
+- Sin tests nuevos para este fix (es documentación/honestidad, no hay comportamiento
+  nuevo que assertar), según lo pedido en el brief.
+
+## Fix 2 — `--export` + `--merge` juntos: `--merge` ganaba en silencio
+
+Antes, `cmd_costo` chequeaba `if merge_pattern:` primero y retornaba sin llegar nunca al
+bloque de `export_dir` — si un usuario pasaba ambos flags, perdía su `--export` sin
+ningún feedback.
+
+Cambio: guard agregado al principio del cuerpo de `cmd_costo`, antes del `if merge_pattern:`
+existente:
+
+```python
+if merge_pattern and export_dir:
+    print("[sensei] --export y --merge son modos distintos — no se pueden combinar. "
+          "Usá --export para generar tu propio archivo, o --merge para sumar exports ya generados.")
+    return 2
+```
+
+Código de retorno elegido: `2`. Los otros paths de error en `cmd_costo` usan `return 1`
+(glob sin matches); `2` es un código distinto que no colisiona con ningún otro path
+existente en la función.
+
+Test nuevo en `tests/test_cli_costo.py`:
+`test_cmd_costo_export_and_merge_together_is_rejected` — llama a `cmd_costo` con ambos
+`export_dir` y `merge_pattern` truthy, y asegura:
+- `result != 0`
+- el mensaje de error menciona tanto `--export` como `--merge`
+- la carpeta de export (`export_dir`) nunca se creó — prueba de que el código nunca
+  llegó al bloque de `costo.export_by_work_item(...)` (no hace falta mockear el glob:
+  si el código hubiera seguido al branch de merge, tampoco habría fallado por archivos
+  inexistentes porque ese path imprime un mensaje distinto "sin archivos que coincidan",
+  pero la aserción decisiva es que `export_dir` nunca existe — si el código hubiera
+  llegado al branch de export, la carpeta se habría creado).
+
+## Resultado de tests
+
+```
+uv run pytest tests/test_costo.py tests/test_cli_costo.py -v
+→ 26 passed
+
+uv run pytest -v --ignore=tests/integration/test_sensei_dojo_interop.py
+→ 257 passed
+
+uv run python -m unittest tests.smoke -v
+→ Ran 42 tests: FAILED (failures=3, errors=2)
+```
+
+`tests/integration/test_sensei_dojo_interop.py` falla en collection
+(`ImportError: cannot import name 'app' from 'dojo'`) — variante local del
+`ModuleNotFoundError: fastapi` mencionado en el brief; confirmado pre-existente
+(reproducido idéntico con `git stash` sobre HEAD antes de mis cambios).
+
+`tests/smoke.py`: los mismos 3 failures + 2 errors (`TestOpencodeCollector` x2,
+`TestCoach.test_cache_rule_fires_on_low_hit`, `TestOpencodeCollector.test_engine_combines_sources`,
+`TestServerReadOnly.test_endpoints_and_readonly`) están presentes de forma idéntica
+en HEAD `c2a821c` sin mis cambios (verificado con `git stash` / `stash pop`). No están
+relacionados con `cmd_costo`/`costo.py` y no son introducidos por este fix.
+
+## Archivos modificados
+
+- `sensei/cli.py` — guard de `--export`+`--merge`, comentario de honestidad sobre
+  `by_work_item`, help text actualizado.
+- `tests/test_cli_costo.py` — un test nuevo.
+
+Nota: el working tree tenía además cambios sin commitear en `.gitignore`,
+`docs/ROADMAP_SPEC.md` y varios `docs/superpowers/plans/*.md` no relacionados con esta
+tarea (pre-existentes, de otro trabajo en curso). No los toqué ni los incluí en el commit.
+
+## Self-review
+
+- Verifiqué que `cmd_costo` no cambió de firma y que ningún caller (`main()`, tests)
+  necesitó ajustes más allá del `help=`.
+- Confirmé que el guard nuevo se ejecuta antes de cualquier I/O (glob, `build_payload`,
+  export) — ambos modos quedan bloqueados atómicamente antes de tocar disco.
+- Confirmé con `git stash`/`git diff` que las fallas de `tests/smoke.py` y la de
+  collection de integración son pre-existentes y no introducidas por este cambio.
+
+## Concerns
+
+- Ninguno bloqueante. El código de retorno `2` es una convención nueva dentro de
+  `cmd_costo` (antes solo usaba `0`/`1`); si en el futuro se agregan más modos de error
+  mutuamente excluyentes convendría documentar la tabla de exit codes de `costo`, pero
+  no era parte del scope de este fix.

onesensei-0.2.0/.superpowers/sdd/progress-org-admin-dashboard-poc-DONE.md

@@ -0,0 +1,25 @@
+# SDD Progress Ledger — Org Admin Dashboard (S4-5, PoC)
+
+Plan: docs/superpowers/plans/2026-07-05-org-admin-dashboard-poc.md
+Branch: sensei/v2 (main tree, no worktree)
+Branch start: 898ccb7
+
+Previous plan's ledger (Work-Item Cost Tracking, complete) archived at:
+.superpowers/sdd/progress-work-item-cost-tracking-DONE.md
+
+## Tasks
+
+- [x] Task 1: Basic-tier raw metrics — cache_hit_pct, repeated_context_pct, roi.py total_value
+- [x] Task 2: dev_summary() — combine into one factual, Pro-aware row
+
+Task 1: complete (commits 898ccb7..c74153c, review Approved — cache_hit_pct verified with zero coupling to Pro-gated coach.py (grep confirmed), total_value verified by independent numerical re-derivation to sum the full session list not just the top-30 scatter. Implementer caught and fixed a flawed test-data example in the brief's own Step 9 (uniform gradient never produces a strict scatter subset), verified as a genuine fix, not scope creep. Accepted, not fixed: plan-mandated duplication of path-resolution helper vs server.py (Important but by design, noted for future consolidation); tautological "does not import coach" test assertion inherited from brief (Minor, actual verification was via grep in review).)
+- [x] Task 3: Carry dev_summary through export, read it back with by_dev()
+
+Task 2: complete (commits c74153c..5c7e007, review Approved — no findings. Four separate keys confirmed, roi_value explicit None (never 0/KeyError) verified including the missing-"pro"-key case, cost correctly summed across all sources, kill-list respected (docstring explicitly cites it).)
+
+Task 3: complete (commits 5c7e007..e8275b1, +97355a1 doc fix. Review Approved — sort key literal `key=lambda r: r["dev"]` pinned by source-inspection test, backward-compat 2-arg path verified to omit (not null) dev/dev_summary via real file round-trip, by_dev() tolerates both corrupt JSON and old-format-missing-summary with distinct warnings, aggregate-only reconstruction confirmed. One Important gap found — module docstring not updated to mention dev/dev_summary fields — fixed directly post-review (97355a1), 37/37 tests still pass.)
+- [x] Task 4: CLI wiring — print the per-dev table and "yours" summary line
+
+Task 4: complete (commit 6f9d6f1, review Approved — no findings. Control flow matches brief exactly, roi_value uses `is not None` (not truthiness) so a real 0.0 ROI would render correctly, all four dev metrics stay in separate columns/fields (kill-list respected), backward-compat 2-arg/3-arg export_by_work_item call sites both still work, no duplicate costo import, all None-guards on format calls verified safe. 10/10 new+existing test_cli_costo.py, 280/280 full suite, tests.smoke at known baseline.)
+
+## ALL TASKS COMPLETE — proceeding to final whole-branch review (898ccb7..HEAD)

onesensei-0.2.0/.superpowers/sdd/progress-sensei-pro-licensing-DONE.md

@@ -0,0 +1,22 @@
+# SDD Progress Ledger — Sensei Pro Licensing Client
+
+Plan: docs/superpowers/plans/2026-07-05-sensei-pro-licensing-client.md
+Branch: sensei/v2 (main tree, no worktree — companion Dojo plan runs isolated in .worktrees/dojo-license-service)
+Branch start: 99b5d80
+
+## Tasks (plan's original 6, all complete — see below for post-final-review fix)
+
+- [x] Task 7 (extra, not in original plan): Gate /api/llm/* — Critical gap found by final whole-branch review (opus). commits 8157611..06d13d6, review Approved. Every endpoint in the required mapping gated with correct PRO_FEATURES name (verified against llm_coach.py function bodies, not just trusted); status/test correctly stay ungated, proven by test. Gate sits before cache-invalidation/payload build. Shared _send_locked() helper de-dupes all 4 403 sites in server.py + a shared constant de-dupes the 2 CLI lock messages. One Important-but-non-functional plan-mandated deviation: _send_locked ended up as (message) not (feature, message) as literally specified — cosmetic API-shape only, behavior/security unaffected, accepted.
+
+- [x] Task 1: Core licensing module — storage, signing, verification (Ed25519 fix commit ba4c57a, review Approved. Residual self-forge-with-own-keypair gap accepted as same risk tier as editing source (spec Decision 3) — user chose to mitigate the narrower "forged/invalid token checked against a reachable real Dojo" case instead. Plan's Task 2 updated: refresh() now distinguishes unreachable Dojo (keep cached) from explicit 403/404 rejection (invalidate immediately).)
+- [x] Task 2: Network layer — connect, refresh, disconnect
+- [x] Task 3: CLI wiring — sensei dojo connect/status/disconnect
+- [x] Task 4: Gate Coach, ROI, Developer Memory in engine.build_payload()
+- [x] Task 5: Gate /api/whatif, /api/profile, /api/graph, sensei profile CLI
+- [x] Task 6: Frontend gate for cache reference band
+
+Task 6: complete (commits 013ee21..8157611, review Approved — implementer's brief-guessed variable name (`data`) was wrong, real one is `D`; also found and fixed a real bug the brief's literal edit would have shipped: normalize() never forwarded p.pro to the client at all, so the new guard would've stayed permanently false even for paying Pro users. Reviewer independently re-derived the whole chain (licensing.PRO_FEATURES -> entitlements() -> payload["pro"] -> normalize() -> D.pro) and confirmed the fix is necessary, minimal, and leaks nothing beyond 5 booleans. ALL 6 TASKS OF THIS PLAN NOW COMPLETE.)
+Task 5: complete (commits 60d140c..013ee21, review Approved — no fail-open path, all feature names verified against PRO_FEATURES, both self-reported deviations (missing handler.headers in the brief's own test stub; an unlisted affected test_smoke_ui.py fixture) independently verified as correct and properly scoped. Two Important-but-cosmetic plan-mandated findings for final review: 403-locked-response construction duplicated 3x in server.py, the CLI lock message duplicated 2x — both literally specified that way in the brief's step-by-step text, pure DRY cleanup candidate, not a correctness/security issue.)
+Task 4: complete (commits 1887fc0..28c543a..60d140c, review Approved after one fix round — first review found tests/smoke.py wasn't in the regression check scope: one test broke for real (test_roi_in_payload, asserted a "disclaimer" key the locked stub lacks), another went vacuous (test_coach_in_full_payload passed only by coincidence against the stub, contradicting its own "datos reales" docstring). Fix patches licensing.entitlements to all-True around build_payload() in both, verified against PRO_FEATURES completely, and confirmed the other 5 pre-existing smoke.py failures are unrelated (predate this task, checked by running against the parent commit and by reading each failing test's body). One pre-existing (not introduced) Minor noted: test_coach_in_full_payload's assertions don't actually distinguish real Coach output from the locked stub shape, even post-fix.)
+Task 3: complete (commits 78bd84a..1887fc0, review Approved — no Critical/Important. Reviewer independently confirmed the dojo-command interception sits before argparse.ArgumentParser construction by reading the actual file, not just the diff. Full suite 217/217, zero regressions to existing CLI commands.)
+Task 2: complete (commits ba4c57a..78bd84a, review Approved — both security properties independently re-verified by the reviewer (exception ordering read live in file, invalidation tests re-run). One inert Minor: refresh()'s disconnect() call uses the license_path param, not current — safe today since all call sites pass them consistently. Implementer self-caught and fixed a real bug in the brief's own example code: cmd_connect must pass http_post=_http_post_json explicitly, since Python binds default params at def-time and monkeypatching the module attribute later doesn't affect an already-bound default — confirmed correct by reviewer.)

onesensei-0.2.0/.superpowers/sdd/progress-work-item-cost-tracking-DONE.md

@@ -0,0 +1,20 @@
+# SDD Progress Ledger — Work-Item Cost Tracking (Sprint 3: S3-1/S3-2/S3-5)
+
+Plan: docs/superpowers/plans/2026-07-05-work-item-cost-tracking.md
+Branch: sensei/v2 (main tree, no worktree — single plan, no parallel stream right now)
+Branch start: 5ecc523
+
+Previous plan's ledger (Sensei Pro Licensing Client, complete, merged) archived at:
+.superpowers/sdd/progress-sensei-pro-licensing-DONE.md
+
+## Tasks
+
+- [x] Task 1: Automatic work-item inference (S3-1)
+- [x] Task 2: `sensei costo --by-work-item` (S3-2)
+
+Task 1: complete (commits 5ecc523..282df05, review Approved — regex/fallback chain verified live for all documented examples, wiring covers all sources not just one, no manual-tagging path. Deviation from brief's guessed test patch target was necessary (brief guessed a nonexistent function name) and resulted in a stronger, less-mocked integration test using the pre-existing tests/fixtures.py:make_fake_claude helper.)
+- [x] Task 3: Export/merge across devs (S3-5)
+
+Task 3: complete (commits 713bbe2..7b2bd75..c2a821c, review Approved after one fix round — three Important findings on the LOCAL ONLY exception function all closed: export now rebuilds rows with only 3 allowed keys by construction (not caller discipline), filename adds hostname to reduce collision risk, merge skips a corrupt file with a named warning instead of crashing the whole team merge. Every fix test asserts the actual guarantee (raw-text leak absence, correct totals with a bad file present), not just non-crash. ALL 3 TASKS OF THIS PLAN NOW COMPLETE.)
+FINAL WHOLE-BRANCH REVIEW (opus): commits c2a821c..898ccb7 — Approved after one fix round. Two Important findings caught only at whole-branch level (no single task review saw them): --by-work-item was a complete no-op (never read in cmd_costo, table showed unconditionally regardless), and --export+--merge together silently discarded --export with no warning. Both fixed: by_work_item's non-gating status documented honestly in code+help text rather than adding premature gating logic (only one view exists today); --export+--merge now rejected with a clear error before either mode runs, proven by a test asserting export_dir is never even created. All principle guarantees (LOCAL ONLY exception airtight, ZERO DEPS intact, kill-list respected, HONEST NUMBERS/sin-asignar consistent end-to-end) reconfirmed at whole-branch level. Remaining Minor findings (no filename-hostname test, corrupt-file granularity is per-file not per-row, no single end-to-end infer->export->merge test) explicitly accepted, not blocking. PLAN FULLY COMPLETE.
+Task 2: complete (commits 282df05..dec136b..713bbe2, review Approved after one small fix — sin asignar bucket never dropped, no argparse collisions with existing commands, cost never recomputed. One Important-plan-mandated gap (no real main()/argparse dispatch test, only direct cmd_costo calls) fixed by adding one test mirroring the dojo dispatch test pattern; verified directly, clean.)

onesensei-0.2.0/.superpowers/sdd/progress.md

@@ -0,0 +1,21 @@
+# SDD Progress Ledger — Pro Lock UI (candado + CTA en tabs Pro)
+
+Plan: docs/superpowers/plans/2026-07-05-pro-lock-ui.md
+Branch: sensei/v2 (main tree, no worktree)
+Branch start: 6f9d6f1
+
+Previous plan's ledger (Org Admin Dashboard PoC, complete) archived at:
+.superpowers/sdd/progress-org-admin-dashboard-poc-DONE.md
+
+## Tasks
+
+- [x] Task 1: Helper compartido de candado + fix del bug de Coach
+- [x] Task 2: Extender el candado a ROI, Perfil y Whatif
+
+Task 1: complete (commit 45c9c18, review Approved — no findings. `_coachReal` fix verified as `p.coach && !p.coach.locked`, `applyProLocks` guards `!D.pro` first, strict `=== false` checks confirmed safe against licensing.entitlements()'s always-boolean contract, demo HTML confirmed genuinely overwritten (not just flag-fixed), tab icon dedup guarded, CTA matches CLI's _PROFILE_LOCKED_MSG verbatim. Bonus fix beyond brief: stale "5" badge count on Coach tab also cleared when locked. 24/24 test_smoke_ui.py, 282/282 full suite, tests.smoke at known baseline.)
+
+Task 2: complete (commit 6c9cdf4, review Approved. ROI/.stat-row replacement, Perfil canvas+adapter hiding, Whatif window._senseiData check, and the Perfil tab-switch guard all verified genuine and idempotent, all strictly === false, no tab hidden, shared _proLockHtml reused everywhere. One Important finding, deferred not fixed here: the app has a live 120s polling loop (setInterval fetchAndRender, no page reload) — so a dev who runs `sensei dojo connect` mid-session stays permanently locked on ROI/Perfil/Whatif (and keeps the 🔒 tab icon from Task 1) until a manual reload, because none of the lock branches has a reverse/unlock path. Coach happens to self-heal only as a side effect of renderCoach always rebuilding its panel when real — not a deliberate mechanism. Out of this task's stated scope; flagged for the final whole-branch review and the user's call on a follow-up. 284/284 full suite, tests.smoke at known baseline.)
+
+## ALL TASKS COMPLETE — final whole-branch review: Ready to merge (no Critical, one Important deferred)
+
+Final review (6f9d6f1..6c9cdf4, opus): Ready to merge. applyProLocks cohesive across both tasks, single _proLockHtml mechanism, strict === false everywhere, tabs never hidden, CTA verbatim, idempotent under the 120s live poll. One Important finding adjudicated as safe-direction and non-blocking: locked surfaces (ROI/Perfil/Whatif/tab icons) don't self-heal on a live reconnect mid-session without a page reload — never leaks fake data, just stays conservative until F5. Added to docs/ROADMAP_SPEC.md's Backlog condicional as item M (2026-07-05) rather than fixed in-branch, per the reviewer's explicit recommendation (a symmetric-unlock fix inverts the plan's one-way lock design at its most sensitive boundary — riskier rushed than deferred).

onesensei-0.2.0/.superpowers/sdd/review-013ee21..8157611.diff

@@ -0,0 +1,118 @@
+# Review package: 013ee21..HEAD
+
+## Commits
+8157611 feat(ui): gate cache reference band behind Pro entitlement
+
+## Files changed
+ sensei/ui/index.html   |  3 ++-
+ tests/test_smoke_ui.py | 22 ++++++++++++++++++++++
+ 2 files changed, 24 insertions(+), 1 deletion(-)
+
+## Diff
+diff --git a/sensei/ui/index.html b/sensei/ui/index.html
+index d700457..9a0c354 100644
+--- a/sensei/ui/index.html
++++ b/sensei/ui/index.html
+@@ -923,20 +923,21 @@ function normalize(p) {
+   }
+ 
+   // Coach real (insights + sugerencias de skills desde reglas)
+   if (p.coach) { d.coach = p.coach; d._coachReal = true; }
+   if (p.maturity) d.maturity = p.maturity;
+ 
+   // Raw sources para análisis de sesiones en el coach
+   if (p.sources) d._sources = p.sources;
+   if (p.goals) d.goals = p.goals;
+   if (p.features) d.features = p.features;
++  if (p.pro) d.pro = p.pro;
+   if (p._history_days) d._historyDays = p._history_days;
+   if (p.llm_narrative) d._llmNarrative = p.llm_narrative;
+   if (p.user_name) d._userName = p.user_name;
+ 
+   // Ya no queda ningún dato demo en modo live: burn se mide via /api/burn
+   return d;
+ }
+ 
+ /* ── 3. RENDER (funciones puras: leen DATA, escriben DOM) ──────── */
+ function renderHeader(D) {
+@@ -3351,21 +3352,21 @@ function renderAll(D) {
+         </div>
+         <button class="llm-explain-btn" style="margin-top:10px"
+           onclick="loadLLMAnomaly(this)"
+           data-session="${oh.name}" data-project="${oh.project}"
+           data-cost="${oh.cost.toFixed(2)}" data-tokens="0" data-kind="rose">¿Por qué?</button>
+         <div class="llm-explain-panel"></div>`;
+       nowPanel.appendChild(card);
+     }
+   }
+   // Cache reference band (G) — solo si feature habilitado y source no vacío
+-  if (feats.cache_reference_band && feats.cache_reference_band.enabled && feats.cache_reference_band.source) {
++  if (feats.cache_reference_band && feats.cache_reference_band.enabled && feats.cache_reference_band.source && D.pro && D.pro.cache_reference_band) {
+     const band = feats.cache_reference_band;
+     const coachPanel = document.getElementById('coach');
+     if (coachPanel && !document.getElementById('cache-band-ref')) {
+       const ref = document.createElement('div');
+       ref.id = 'cache-band-ref';
+       ref.style.cssText = 'font-family:"JetBrains Mono",monospace;font-size:11px;color:var(--text-faint);background:var(--bg-elev);border:1px solid var(--line);border-radius:8px;padding:10px 14px;margin-top:12px;';
+       const p50 = band.p50 != null ? `p50 ${band.p50}%` : '';
+       const p90 = band.p90 != null ? `· p90 ${band.p90}%` : '';
+       ref.innerHTML = `Referencia cache hit — ${p50} ${p90} · Fuente: <em>${band.source}</em>`;
+       coachPanel.appendChild(ref);
+diff --git a/tests/test_smoke_ui.py b/tests/test_smoke_ui.py
+index 5dd2c06..50d9237 100644
+--- a/tests/test_smoke_ui.py
++++ b/tests/test_smoke_ui.py
+@@ -4,20 +4,21 @@ Sin navegador ni dependencias (ZERO DEPS): valida códigos de estado, formas
+ mínimas de respuesta y que el dashboard servido contenga los contenedores y
+ funciones que los endpoints alimentan — el pegamento que los unit tests no ven.
+ """
+ from __future__ import annotations
+ import json
+ import threading
+ import time
+ import urllib.error
+ import urllib.request
+ from http.server import ThreadingHTTPServer
++from pathlib import Path
+ 
+ import pytest
+ 
+ from sensei import server
+ 
+ _PAYLOAD = {
+     "totals": {"cost": 10.0, "tokens": 1000, "clients": 1},
+     "sources": {"claude_code": {"by_session": [], "by_model": {}}},
+     "projects": [], "trend": [], "coach": {"insights": [], "skill_suggestions": [],
+                                            "summary": {"insights": 0, "suggestions": 0}},
+@@ -118,10 +119,31 @@ def test_live_es_pagina_propia(srv):
+     html = body.decode("utf-8")
+     for needle in ("En vivo", "sensei statusline", "/api/live"):
+         assert needle in html, f"falta {needle!r} en live.html"
+ 
+ 
+ def test_settings_trae_objetivos(srv):
+     _, body = _get(srv, "/settings")
+     html = body.decode("utf-8")
+     for element_id in ("goal-budget", "goal-score", "client-budgets-wrap"):
+         assert f'id="{element_id}"' in html, f"falta #{element_id} en settings.html"
++
++
++def test_cache_reference_band_checks_pro_entitlement():
++    """La banda de referencia de cache es una feature Pro (licensing.PRO_FEATURES).
++
++    El guard en renderAll(D) no debe depender solo del feature flag (feats,
++    config local) — también debe exigir el entitlement real calculado por
++    engine.build_payload() en payload["pro"]["cache_reference_band"], que
++    llega al front como D.pro (no `feats`, no `data`: la función que envuelve
++    este guard es renderAll(D) y feats = D.features).
++    """
++    html = (Path(__file__).parent.parent / "sensei" / "ui" / "index.html").read_text(encoding="utf-8")
++    guard_line = (
++        "if (feats.cache_reference_band && feats.cache_reference_band.enabled && "
++        "feats.cache_reference_band.source && D.pro && D.pro.cache_reference_band) {"
++    )
++    assert guard_line in html
++    # Sin esto, D.pro nunca existiría (normalize() no reenviaba `pro` desde el
++    # payload del server) y el guard de arriba sería siempre false — la banda
++    # jamás se mostraría, ni para usuarios Pro.
++    assert "if (p.pro) d.pro = p.pro;" in html

onesensei-0.2.0/.superpowers/sdd/review-170bf5c..01d3cd7.diff

@@ -0,0 +1,228 @@
+# Review package: 170bf5c..HEAD
+
+## Commits
+01d3cd7 fix(ui): remove out-of-scope loadLLMRoiAnalysis from task-3 commit
+a2d9358 fix: cache LLM en disco — persiste entre reinicios del servidor
+
+## Files changed
+ sensei/llm_coach.py  | 51 +++++++++++++++++++++++++++++++++++++++------------
+ sensei/server.py     | 20 +++++++++++++++++++-
+ sensei/ui/index.html | 23 -----------------------
+ 3 files changed, 58 insertions(+), 36 deletions(-)
+
+## Diff
+diff --git a/sensei/llm_coach.py b/sensei/llm_coach.py
+index 27afbb7..a59fbfb 100644
+--- a/sensei/llm_coach.py
++++ b/sensei/llm_coach.py
+@@ -13,44 +13,41 @@ Features:
+   claudemd_for_project()  → CLAUDE.md sugerido para un proyecto (Proyectos tab)
+   skill_template()        → template de skill listo para copiar (Coach skills)
+   explain_anomaly()       → explicación de sesión rose (ROI tab)
+   daily_briefing()        → script oral para el orbe del Resumen tab
+ """
+ from __future__ import annotations
+ import shutil
+ import subprocess
+ import json
+ import time
++from pathlib import Path
+ 
+ 
+ TIMEOUT = 30         # segundos por subprocess
+ CACHE_TTL = 900      # 15 min — narrativa coach
+ TTL_RECAP = 3600     # 1 hora — recap semanal
+ TTL_MD    = 3600     # 1 hora — CLAUDE.md por proyecto
+ TTL_SKILL = 1800     # 30 min — skill templates
+ TTL_BRIEFING = 1800  # 30 min — briefing oral del orbe
+ TTL_ANOMALY = 1800 # 30 min — explicaciones de sesión
+ TTL_PROFILE_NARRATIVE = 3600   # 1 hora — narrativa del grafo
+ TTL_CLAUDEMD_GLOBAL   = 3600   # 1 hora — CLAUDE.md global
+ TTL_NODE_EXPLAIN      = 1800   # 30 min — explicación por nodo
+ 
+-_caches: dict[str, dict] = {
+-    "narrative":         {},
+-    "recap":             {},
+-    "claudemd":          {},   # key: project name
+-    "skill":             {},   # key: skill name
+-    "anomaly":           {},   # key: session name
+-    "briefing":          {},
+-    "profile_narrative": {},   # key: hash del prompt con grafo
+-    "claudemd_global":   {},   # key: hash del prompt con grafo + md
+-    "node_explain":      {},   # key: hash de "name:type"
+-}
++_caches: dict[str, dict] = {}
++_CACHE_DIR = Path.home() / ".sensei" / "cache" / "llm"
++
++
++def _cache_file(bucket: str, sub_key: str) -> Path:
++    safe = sub_key.replace("/", "_").replace(":", "_")[:64]
++    return _CACHE_DIR / bucket / f"{safe}.json"
+ 
+ 
+ # ── CLI detection ─────────────────────────────────────────────────────────────
+ 
+ def _detect_cli() -> tuple[str, list[str]] | None:
+     if shutil.which("claude"):
+         return ("claude", ["claude", "-p"])
+     if shutil.which("opencode"):
+         return ("opencode", ["opencode", "run", "--quiet"])
+     return None
+@@ -70,33 +67,63 @@ def _run(prompt: str) -> str | None:
+     except Exception:
+         return None
+ 
+ 
+ def _cli_name() -> str:
+     cli = _detect_cli()
+     return cli[0] if cli else "rule-based"
+ 
+ 
+ def _cached(cache_key: str, sub_key: str, ttl: int):
+-    """Devuelve el valor cacheado si es fresco, None si expiró."""
++    """Devuelve el valor cacheado (memoria → disco), None si expiró o no existe."""
+     store = _caches.get(cache_key, {})
+     entry = store.get(sub_key)
+     if entry and time.monotonic() < entry.get("expires_at", 0):
+         return entry["value"]
++    try:
++        f = _cache_file(cache_key, sub_key)
++        if f.exists():
++            data = json.loads(f.read_text(encoding="utf-8"))
++            if time.time() < data.get("expires_ts", 0):
++                remaining = data["expires_ts"] - time.time()
++                _caches.setdefault(cache_key, {})[sub_key] = {
++                    "value": data["value"],
++                    "expires_at": time.monotonic() + remaining,
++                }
++                return data["value"]
++    except Exception:
++        pass
+     return None
+ 
+ 
+ def _store(cache_key: str, sub_key: str, value, ttl: int):
+     _caches.setdefault(cache_key, {})[sub_key] = {
+         "value": value,
+         "expires_at": time.monotonic() + ttl,
+     }
++    try:
++        f = _cache_file(cache_key, sub_key)
++        f.parent.mkdir(parents=True, exist_ok=True)
++        f.write_text(
++            json.dumps({"value": value, "expires_ts": time.time() + ttl}, ensure_ascii=False),
++            encoding="utf-8",
++        )
++    except Exception:
++        pass
++
++
++def invalidate_bucket(bucket: str) -> None:
++    """Borra todas las entradas de caché (memoria + disco) de un bucket."""
++    _caches.pop(bucket, None)
++    cache_dir = _CACHE_DIR / bucket
++    if cache_dir.exists():
++        shutil.rmtree(cache_dir, ignore_errors=True)
+ 
+ 
+ # ── 1. Narrativa coach ────────────────────────────────────────────────────────
+ 
+ def _narrative_prompt(payload: dict) -> str:
+     m = payload.get("maturity", {})
+     t = payload.get("totals", {})
+     projects = payload.get("projects", [])
+     signals = m.get("signals", [])
+     warn_sigs = [s["label"] for s in signals if s.get("status") == "warn"]
+diff --git a/sensei/server.py b/sensei/server.py
+index c25f87c..7a1d190 100644
+--- a/sensei/server.py
++++ b/sensei/server.py
+@@ -83,21 +83,39 @@ class _Handler(BaseHTTPRequestHandler):
+                     profile["graph"] = _json.loads(graph_file.read_text(encoding="utf-8"))
+                 self._send(200, _json.dumps(profile, ensure_ascii=False).encode("utf-8"))
+             except Exception as e:
+                 self._send(500, json.dumps({"error": str(e)}).encode())
+         # ── /api/llm/* — generación LLM on-demand con fallback ───────────────
+         elif self.path.startswith("/api/llm/"):
+             try:
+                 from . import llm_coach
+                 parsed   = urllib.parse.urlparse(self.path)
+                 qs       = urllib.parse.parse_qs(parsed.query)
+-                endpoint = parsed.path  # e.g. /api/llm/recap
++                endpoint = parsed.path
++
++                if qs.get("refresh", ["0"])[0] == "1":
++                    _BUCKET_MAP = {
++                        "/api/llm/narrative": "narrative",
++                        "/api/llm/recap": "recap",
++                        "/api/llm/roi_analysis": "roi",
++                        "/api/llm/coach_plan": "coach_plan",
++                        "/api/llm/briefing": "briefing",
++                        "/api/llm/anomaly": "anomaly",
++                        "/api/llm/insight": "insight",
++                        "/api/llm/claudemd": "claudemd",
++                        "/api/llm/skill": "skill",
++                        "/api/llm/profile_narrative": "profile_narrative",
++                        "/api/llm/claudemd_global": "claudemd_global",
++                        "/api/llm/node_explain": "node_explain",
++                    }
++                    if endpoint in _BUCKET_MAP:
++                        llm_coach.invalidate_bucket(_BUCKET_MAP[endpoint])
+ 
+                 payload = build_payload(self.cfg)
+ 
+                 if endpoint == "/api/llm/narrative":
+                     result = llm_coach.generate(payload)
+                     self._send(200, json.dumps(result, ensure_ascii=False).encode("utf-8"))
+ 
+                 elif endpoint == "/api/llm/recap":
+                     result = llm_coach.weekly_recap(payload)
+                     self._send(200, json.dumps(result, ensure_ascii=False).encode("utf-8"))
+diff --git a/sensei/ui/index.html b/sensei/ui/index.html
+index 748bbc7..e1989aa 100644
+--- a/sensei/ui/index.html
++++ b/sensei/ui/index.html
+@@ -1392,43 +1392,20 @@ function loadLLMNodeExplain(btn) {
+       btn.textContent = '¿Qué dice esto de mí?';
+       btn.disabled = false;
+     })
+     .catch(() => {
+       if (panel) { panel.classList.remove('open'); panel.innerHTML = ''; }
+       btn.textContent = '¿Qué dice esto de mí?';
+       btn.disabled = false;
+     });
+ }
+ 
+-// ── Interpretación del scatter ROI ────────────────────────────────────────
+-let _roiAnalysisLoaded = false;
+-function loadLLMRoiAnalysis() {
+-  if (_roiAnalysisLoaded) return;
+-  const block = document.getElementById('roi-llm-block');
+-  const textEl = document.getElementById('roi-llm-text');
+-  const srcEl  = document.getElementById('roi-llm-src');
+-  if (!block || !textEl) return;
+-  block.style.display = 'block';
+-  textEl.innerHTML = _llmGenHtml('Interpretando gráfico…');
+-  fetch('/api/llm/roi_analysis')
+-    .then(r => r.ok ? r.json() : null)
+-    .then(result => {
+-      if (result?.text) {
+-        textEl.textContent = result.text;
+-        if (srcEl) srcEl.textContent = result.cli ? `Generado con ${result.cli}` : '';
+-        _roiAnalysisLoaded = true;
+-      } else {
+-        block.style.display = 'none';
+-      }
+-    })
+-    .catch(() => { block.style.display = 'none'; });
+-}
+ // ── CLAUDE.md por proyecto (Proyectos tab) ────────────────────────────────
+ function loadLLMClaudeMd(btn) {
+   const project  = btn.dataset.project;
+   const sessions = btn.dataset.sessions || 1;
+   const cost     = btn.dataset.cost || 0;
+   const panel    = btn.closest('.proj-llm-wrap').querySelector('.llm-claudemd-panel');
+   if (panel.classList.contains('open')) { panel.classList.remove('open'); panel.innerHTML = ''; btn.textContent = 'CLAUDE.md sugerido'; return; }
+   btn.textContent = 'Generando…';
+   btn.disabled = true;
+   panel.innerHTML = _llmGenHtml('Generando CLAUDE.md…');

onesensei-0.2.0/.superpowers/sdd/review-183607c..183607c.diff

@@ -0,0 +1,7 @@
+# Review package: 183607c0df33de386fc636b8214a28c1383db0c0..HEAD
+
+## Commits
+
+## Files changed
+
+## Diff