corvusmem 0.5.1 → 0.6.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/CHANGELOG.md CHANGED
@@ -5,6 +5,96 @@ Format based on [Keep a Changelog](https://keepachangelog.com/); versions follow
5
5
 
6
6
  ## [Unreleased]
7
7
 
8
+ ## [0.6.0] — 2026-11-18
9
+ ### Added
10
+ - **Head-to-head benchmark vs paid memory products (`tools/eval-productos/`).** Corvusmem's memory engine measured
11
+ against **mem0** and **Zep/Graphiti** on the academic **LoCoMo** benchmark (1986 questions), under identical
12
+ conditions (same local Qwen3 answerer + judge; only the memory differs). Corvusmem **beats mem0 globally**
13
+ (25.6 % vs 21.1 %) and **nearly triples it on temporal** questions (16.2 % vs 5.3 %). And in its **native,
14
+ LLM-free mode** — indexing the raw turns, which is how the product actually works — Corvusmem reaches
15
+ **34.8 % global, the highest of every column measured**, above the free embedding baseline with LLM ingestion
16
+ (28.0 %) and its own LLM-ingestion variant (25.6 %): its retrieval pulls the answer-bearing turn **2–4× more
17
+ often** than a semantic embedding, deterministically and offline. Honest caveat documented: local Qwen3, not
18
+ GPT-4o, so not comparable to their official leaderboards; and with LLM-cleaned facts the embedding still wins
19
+ two single categories (cat1, cat3). Raw results + `comparar.mjs` reproduce the tables offline (`BENCHMARK.md`).
20
+ Dev tooling — not shipped in the npm package.
21
+ - **`corvusmem --health` and a reliability panel in the Cortex.** One source (`datosSalud`) answers "is the memory
22
+ working?": active facts (and by family), open goals/todos, real-world use (injected vs used, real precision from your
23
+ own sessions), the deterministic battery result (`hit@5`, abstention, dedup, ms — shown only where the dev eval
24
+ exists), and what the last session saved or skipped. The Cortex shows the same as a panel that reads without
25
+ JavaScript; private rows (real use, last session) are owner-only and never travel to the client view or its JSON.
26
+ - **Fact-shaped nudges while you work (high precision).** Beyond rules/corrections, the live hook now spots statements
27
+ that carry a reusable datum — a tool in use (`we use X`), a figure with a currency (`charges 600 €`), a location
28
+ (`vivo en Madrid`), an office/API named — and nudges the agent to save it, then leaves a non-blocking reminder at
29
+ close if nothing was saved. A **question is never treated as a fact**, so `which package manager do we use` or
30
+ `cuánto paga…` stay silent: 0 false positives across the whole adversarial battery. The detector is pure and tested
31
+ (`tests/test-hecho-detector.mjs`, 34/0); the close nudge only ever emits `systemMessage`, never blocks.
32
+ - **Deterministic fact extractor — the agent no longer has to invent the key.** When you state a fact-shaped
33
+ sentence, the live hook now **distills the save command itself** (`--dimension … --valor … --claves …`, already
34
+ canonical) and offers it for the agent to review, instead of leaving the agent to pick the key (the cause of saves
35
+ landing under the wrong dimension/store). Pure and canonical (`dimensionConvencional`/`clavesConvencionales`), tested
36
+ (`tests/test-extractor.mjs` 83/0; integration `tests/test-extractor-integracion.mjs` 12/0 proving extract → store →
37
+ recall and chronological substitution). De-risked on LongMemEval knowledge-update (n=21): the compressed fact régimen
38
+ beats raw turns on **both recall@5 and abstention**.
39
+
40
+ ### Improved
41
+ - **Less noise from the project diary (higher real-world precision).** Live recall now gives diary/decision hits an
42
+ **absolute floor** (`0.25–0.35 × the diary's own score scale`, auto-calibrated from your usage history and scaled by
43
+ confidence) on top of the relative threshold. The diary was ~70 % of injected noise — injected on weak overlap
44
+ because it only had to be "best of its source"; facts and standing preferences are untouched, and projects without
45
+ enough history get no floor (behavior unchanged). Measured on real usage logs: injection precision **23.7 % →
46
+ 28.8 %** (new `npm run bench:precision`), ~6 noisy injections cut per useful one lost, with the battery's
47
+ **abstention held at 100 %**.
48
+ - **Clearer bar for what to save (less agent variance).** The save prompt is now one concrete, positive checklist
49
+ (`save.criterios`) — decision made, limit/constraint found, stable preference, external fact with a name/figure,
50
+ a gotcha and its cause, a goal/pending — with the test "would you need it next time and it's not in the code?".
51
+ The same bar is shown at session start and at the close nudge (it replaced the vague "did the user say anything
52
+ stable?" that invited a "no"), so different agents converge on saving the same things.
53
+ - **Recall understands more paraphrases, deterministically.** The concept lexicon that already powers cross-language
54
+ recall gained the missing concepts (`indentation`, `office`, `deploy`, `fee/charge`), so a query phrased differently
55
+ from the stored fact (`sangrar`≈indent, `publicar`≈deploy, `sede`≈office, `charge`≈cobra) now finds it — no
56
+ embeddings, no network. On the adversarial battery: injected hit@5 **63.6 % → 90.9 %** with **abstention held at
57
+ 100 %** (never recall more by inventing more). The one query that still misses is one the engine *should* decline —
58
+ it names something memory never heard (`API`), so it stays silent on purpose ("knows what it doesn't know"); the
59
+ battery now tracks that as an abstention check, not a recall miss.
60
+ ### Added
61
+ - **The memory battery is now a CI gate.** `npm test` runs `eval-memoria --gate`, which fails the build if recall or
62
+ honesty regress: injected hit@5 must stay ≥ 90 %, abstention must stay 100 %, near-duplicate guard 100 %, and the
63
+ battery can't be gutted (a minimum case count). The reliability work can't silently rot.
64
+ - **Memory reliability battery (`tools/eval-memoria/`).** A deterministic, LLM-free adversarial eval of the recall
65
+ engine — paraphrase, synonyms, cross-language, temporal and trap queries — that reports **hit@5**, **injected hit@5**
66
+ (≥ threshold), **abstention precision**, **near-duplicate guard** and **ms/query**, and writes `resultados.json`.
67
+ This is the baseline and, later, the regression gate for the F15 "reliable memory" work. First baseline
68
+ (2026-11-09): hit@5 81.8 % · injected 63.6 % · abstention 100 % · dedup 100 % · ~2 ms/query.
69
+
70
+ ### Fixed
71
+ - **The plugin test is now isolated from a globally-installed Corvusmem.** `test-plugin`'s "no install → npx
72
+ fallback" check read the real `~/.config/corvusmem`, so it failed on a machine that has Corvusmem installed
73
+ globally — which also blocked `npm version`/`npm publish`, since both run `test:core`. It now points `HOME` at
74
+ an empty temp dir for that one assertion. `test:core` is green end to end.
75
+
76
+ ## [0.5.3] — 2026-11-09
77
+ ### Added
78
+ - **Ready for the Anthropic plugin directory.** The generated plugin now ships a square listing **icon**
79
+ (`.claude-plugin/icon.png` — the crow on a dark background), a `displayName`, and a plain `https://` `repository`
80
+ URL (the directory drops `git+…`/`.git`). `claude plugin validate --strict ./plugins/corvusmem` now passes clean,
81
+ so Corvusmem can be submitted to the directory at claude.ai/directory/manage (the git marketplace still works as-is).
82
+ ### Added
83
+ - **`/corvus-install` — bake Corvusmem into a project, as a command.** A new slash command (bundled in the plugin and
84
+ in `.claude/commands/`) installs the hooks into the **current** project so it carries its own memory. Commit
85
+ `.corvusmem/` and `.claude/settings.json` and a teammate who receives the project gets Corvus firing in Claude Code
86
+ or Codex **with nothing to install**. `install.mjs` now ships inside the plugin and runs from it (the core is resolved
87
+ from `hooks/` when there is no `src/`), so the command works natively — `npx corvusmem install` stays as the fallback.
88
+ - **Collapsible Cortex side panel.** The Cortex's right panel now has a header and a collapse button; hide it and the
89
+ brain fills the width, with a floating button to bring it back (remembered per viewer). The panel also got a lighter
90
+ touch: a search icon, section dividers and a cleaner header.
91
+ ### Fixed
92
+ - **`corvusmem import` ran only from the repo, not the plugin** — `cli/import.mjs` imported the engine from `../src/`,
93
+ which does not exist inside the plugin (the core is in `hooks/`), so `/corvus-absorb` crashed when Corvus was
94
+ installed as a plugin. It now resolves the engine from `src/` or `hooks/`, whichever is present.
95
+ - **The Cortex was written to a loose `cortex/` folder at the project root.** It now always renders inside
96
+ `.corvusmem/cortex/`, next to the memory it draws — never a stray folder in the root (or in `senzu/`).
97
+
8
98
  ## [0.5.1] — 2026-11-08
9
99
  ### Changed
10
100
  - **The Cortex gets a header with the crow.** The full Cortex (`/corvus-cortex`) now shows the Corvusmem crow in its
package/README.md CHANGED
@@ -37,6 +37,22 @@ Your agent forgets everything between sessions. Corvusmem is a memory it keeps:
37
37
  graph, retrieved by name, date and relevance with two-hop activation — no embeddings, no vector database, no API key.
38
38
  Same input, same result. The whole memory is a file you own.
39
39
 
40
+ ## Benchmarks
41
+ On **LoCoMo** — the academic long-conversation benchmark (1986 questions) — measured against the paid memory products
42
+ **mem0** and **Zep/Graphiti** under identical conditions (same local Qwen3 answerer and judge; only the memory differs):
43
+
44
+ - In its **native, LLM-free mode** — indexing the raw turns, which is how the product actually works — Corvusmem scores
45
+ **34.8 % end-to-end, the highest of every configuration measured**: above mem0 (21.1 %) and above a free embedding
46
+ baseline (28.0 %), while being deterministic, offline and $0.
47
+ - Its retrieval pulls the answer-bearing turn **2–4× more often** than a semantic embedding, in every category.
48
+ - **Honest caveat:** this runs on a local Qwen3, not GPT-4o, so the absolute numbers are **not** comparable to their
49
+ official GPT-4o leaderboards; and with LLM-cleaned facts the embedding still wins two single categories. It is a
50
+ controlled, reproducible head-to-head between memories, not a leaderboard claim.
51
+
52
+ Full tables, raw results and a one-command reproduction:
53
+ [`BENCHMARK.md`](https://github.com/petersonsenadevs/corvusmem/blob/main/tools/eval-productos/BENCHMARK.md) ·
54
+ [benchmarks on the site](https://corvusmem.vercel.app/benchmarks).
55
+
40
56
  ## Structure
41
57
  - `src/` — the core: the facts engine (`facts.mjs`), shared base (`lib`, `messages`, `session-end`), host detection
42
58
  (`host.mjs`) and the brain hooks (`live-recall`, `session-start`, `session-state`, `live-memory`,
@@ -80,15 +96,16 @@ manifest). The bare `npx corvusmem --save/--recall` still works for an agent wit
80
96
  project (`--global`, in your home). It does **not** change where memory lives: project facts always land in that repo's
81
97
  `.corvusmem/`, your personal facts in `~/.config/corvusmem/`.
82
98
 
83
- **Sharing with a team**: commit `.corvusmem/` (the shared project memory) and, for a per-project install,
84
- `.claude/settings.json` so teammates get the hooks the moment they clone. Never commit `~/.config/corvusmem/` — that is
85
- your private memory.
99
+ **Sharing with a team**: run **`/corvus-install`** (or `npx corvusmem install`) to bake the hooks into the current
100
+ project, then commit `.corvusmem/` (the shared project memory) and `.claude/settings.json` — teammates get Corvus firing
101
+ the moment they clone, with nothing to install. Never commit `~/.config/corvusmem/` — that is your private memory.
86
102
 
87
103
  ## Usage
88
104
  Once installed, the agent captures and recalls memory on its own — you don't do a thing. Two slash commands come with
89
105
  it (native — no `npx`):
90
106
  - **`/corvus-cortex`** — open the Cortex: your whole memory as a local HTML "brain" (offline).
91
107
  - **`/corvus-absorb`** — pull the knowledge already in the repo (CLAUDE.md, docs…) into memory, once.
108
+ - **`/corvus-install`** — bake Corvus into the current project (per-project), so you can commit it and share it.
92
109
 
93
110
  To look at or steer memory from the **terminal** (handy for any agent, or no agent at all):
94
111
  ```
Binary file
package/cli/import.mjs CHANGED
@@ -3,7 +3,14 @@
3
3
  // `corvusmem import` — list the memory documents already in this project, in two tiers, so the agent
4
4
  // (via /corvus-absorb) can read them and save what matters. Deterministic, offline, READ-ONLY: it writes
5
5
  // nothing to memory. `--json` prints the machine-readable contract the command consumes.
6
- import { escanearMemoria } from '../src/import.mjs';
6
+ import fs from 'node:fs';
7
+ import path from 'node:path';
8
+ import { fileURLToPath, pathToFileURL } from 'node:url';
9
+ // El motor vive en ../src (repo) o ../hooks (dentro del plugin): resuelve el que exista, así `corvusmem import`
10
+ // (y /corvus-absorb) funciona también instalado como plugin, no solo desde el repo.
11
+ const AQUI = path.dirname(fileURLToPath(import.meta.url));
12
+ const motor = [path.join(AQUI, '..', 'src', 'import.mjs'), path.join(AQUI, '..', 'hooks', 'import.mjs')].find(f => fs.existsSync(f));
13
+ const { escanearMemoria } = await import(pathToFileURL(motor).href);
7
14
 
8
15
  const argv = process.argv.slice(2);
9
16
  const json = argv.includes('--json');
package/cli/memory.mjs CHANGED
@@ -32,6 +32,7 @@ const ALIAS_FLAG = {
32
32
  '--limit': '--limite', '--budget': '--presupuesto', '--reason': '--motivo', '--link': '--enlazar',
33
33
  '--links': '--enlaces', '--client': '--cliente', '--text': '--texto', '--report': '--informe',
34
34
  '--output': '--salida', '--all': '--todo', '--none': '--nada', '--as': '--como', '--author': '--autor',
35
+ '--health': '--salud',
35
36
  };
36
37
  const ALIAS_VAL = { user: 'usuario', project: 'proyecto', agent: 'agente' }; // valores de enum en inglés
37
38
  for (let i = 0; i < args.length; i++) if (ALIAS_FLAG[args[i]]) args[i] = ALIAS_FLAG[args[i]];
@@ -181,5 +182,32 @@ if (opt('--cortex')) { // Cortex: la memoria en un HTML local, sin red; --clie
181
182
  if (!cliente) out(' Tiene datos privados: para enseñarlo, genera la vista para el cliente con --cortex --cliente.');
182
183
  process.exit(0);
183
184
  }
184
- out('Usage: --save --dimension <family.topic> --value <text> [--keys a,b] [--scope user] [--doubt] | --search <query> [--history] | --context | --list [--all] | --forget <id> | --cortex [--client] [--output <dir>]');
185
+ if (opt('--salud')) { // F15-T8: la salud de la memoria en números (hechos, uso real, batería, última sesión)
186
+ if (!m.datosSalud) { out('Este Corvus no trae --health todavía: actualízalo.'); process.exit(2); }
187
+ const s = m.datosSalud(root, { dias: Number(opt('--dias')) || 30 });
188
+ if (opt('--json')) { out(JSON.stringify(s, null, 2)); process.exit(0); }
189
+ out(`Corvusmem · salud de la memoria (${root})`);
190
+ const fam = Object.entries(s.hechos.porFamilia).sort((a, b) => b[1] - a[1]).map(([k, v]) => `${k} ${v}`).join(' · ');
191
+ out('\nHechos');
192
+ out(` ${s.hechos.activos} activos${s.hechos.dudosos ? ` · ${s.hechos.dudosos} dudosos` : ''} · ${s.hechos.historico} en histórico · ${s.hechos.abiertos} objetivos/pendientes abiertos`);
193
+ if (fam) out(` por familia: ${fam}`);
194
+ if (s.pistasSaturadas && s.pistasSaturadas.length) { // F17-T4: efecto fan — pistas con muchos hechos (interferencia)
195
+ out('\nPistas saturadas (efecto fan: concreta la consulta)');
196
+ for (const p of s.pistasSaturadas) out(` «${p.dimension}» · ${p.hechos} hechos · interferencia ${p.interferencia}`);
197
+ }
198
+ out(`\nUso real (últimos ${s.uso ? s.uso.dias : 30} días)`);
199
+ if (s.uso) out(` ${s.uso.mensajes} mensajes · ${s.uso.inyectados} recuerdos inyectados · ${s.uso.usados} usados · ${s.uso.ignorados} ignorados`
200
+ + (s.uso.precision != null ? ` · precisión real ${s.uso.precision} %` : ''));
201
+ else out(' sin registro todavía: se llena solo al hablar con el agente.');
202
+ out('\nBatería (eval determinista)');
203
+ if (s.bateria) out(` hit@5 inyectado ${s.bateria.hit5} % · abstención ${s.bateria.abstencion} % · duplicados ${s.bateria.duplicados} % · ${s.bateria.ms} ms/consulta (${s.bateria.consultas} consultas, ${s.bateria.fecha})`);
204
+ else out(' no disponible en una instalación (es una herramienta de desarrollo del repo).');
205
+ out('\nÚltima sesión');
206
+ if (s.ultimaSesion && s.ultimaSesion.fecha) {
207
+ if (s.ultimaSesion.guardo) out(` ${s.ultimaSesion.fecha} · guardó ${s.ultimaSesion.guardo} hecho(s): ${s.ultimaSesion.hechos.map(h => `[${h.dimension}]`).join(' ')}`);
208
+ else out(` ${s.ultimaSesion.fecha} · no guardó nada${s.ultimaSesion.archivos ? ` (tocó ${s.ultimaSesion.archivos} archivos)` : ''}`);
209
+ } else out(' sin datos de sesión todavía.');
210
+ process.exit(0);
211
+ }
212
+ out('Usage: --save --dimension <family.topic> --value <text> [--keys a,b] [--scope user] [--doubt] | --search <query> [--history] | --context | --list [--all] | --health | --forget <id> | --cortex [--client] [--output <dir>]');
185
213
  process.exit(2);
@@ -0,0 +1,17 @@
1
+ ---
2
+ description: Bake Corvusmem's hooks into the CURRENT project (not global), so the project carries its own memory and a teammate who receives it gets Corvus working with nothing to install. A local command, not an npx call.
3
+ ---
4
+
5
+ Install **Corvusmem into this project** (per-project, not global). This writes the hooks and the memory CLI into the project's own `.corvusmem/` and wires `.claude/settings.json` with a portable `${CLAUDE_PROJECT_DIR}` path — so if the user **commits `.corvusmem/` and `.claude/settings.json`**, anyone who clones or receives the project has Corvus firing in Claude Code or Codex **without installing anything** (no plugin, no global setup).
6
+
7
+ Run it with the **fastest local path available** — do not default to `npx` (that is only the fallback for an agent with nothing installed). Use the first of these that applies:
8
+
9
+ - **Installed as a plugin** (the `CLAUDE_PLUGIN_ROOT` env var is set): `node "$CLAUDE_PLUGIN_ROOT/cli/corvusmem.mjs" install`
10
+ - **Nothing installed** (fallback only): `npx corvusmem install`
11
+
12
+ It is merge-safe (never overwrites the user's own hooks or permissions) and idempotent. Do **not** pass `--global` here — that would turn the hooks on for every project instead of baking them into this one. After it runs:
13
+
14
+ - Tell the user it installed into **this project only**, and that to share it they should commit `.corvusmem/` and `.claude/settings.json`.
15
+ - Note that `.corvusmem/cortex/` is generated (it ignores itself), and `.corvusmem/memory/` holds the project's facts — commit it to share the memory, or leave it out to keep each person's separate. Their personal memory lives in `~/.config/corvusmem/` and is never shared.
16
+
17
+ Pick the user's language for anything you say. Never invent what the command did — report what it actually printed.
@@ -12,8 +12,9 @@ export const TEXTOS = {
12
12
  vistaClienteT: 'Así lo verá el cliente: sin lo tuyo, lo deducido ni los comandos', claro: 'Claro', oscuro: 'Oscuro', idioma: 'Idioma', vista: 'Vista',
13
13
  pista: 'Toca una zona para ver lo que guarda', pista3d: 'Arrástralo para girarlo en cualquier dirección · doble clic: de lado · cada destello es un recuerdo que se usa',
14
14
  piensa: 'Ver cómo piensa', pararP: 'Parar', piensaT: 'Reproduce sus últimas consultas a la memoria, encendiendo cada zona que tocó', masUsa: 'Lo que más consulta ({d} días):', sinUso: 'Aún no hay uso registrado: brilla según lo que guarda cada zona.', nadaEncontro: 'no encontró nada', loUso: 'lo usó', noLoUso: 'no lo usó', paso: '{i} de {n}',
15
- buscar: 'Pregunta a la memoria…', buscarL: 'Buscar en la memoria', semana: 'Esta semana', nadaSemana: 'Nada nuevo en los últimos 7 días.',
15
+ buscar: 'Pregunta a la memoria…', buscarL: 'Buscar en la memoria', panelTitulo: 'Memoria', panelOcultar: 'Ocultar panel', panelVer: 'Ver panel', semana: 'Esta semana', nadaSemana: 'Nada nuevo en los últimos 7 días.',
16
16
  sigueAbierto: 'Sigue abierto', todo: 'Todo lo que recuerda', coincide: 'Lo que coincide',
17
+ salud: { t: 'Fiabilidad', hechos: 'Hechos', bateria: 'Batería (eval)', uso: 'Uso real', sesion: 'Última sesión' },
17
18
  sinRes: 'Nada en la memoria para «{q}». Si no está aquí, la memoria no lo sabe.', zonaVacia: 'Aún no hay nada en esta zona.',
18
19
  vacia: 'La memoria está vacía. Se llena sola cuando hablas con el agente.', verMas: 'Ver {n} más',
19
20
  quien: 'Quién lo dijo', desde: 'Desde', usado: 'Usado', enDevlog: 'En el devlog', historia: 'Historia', relacionado: 'Relacionado', cambiar: 'Para cambiarlo:', cerrar: 'Cerrar el detalle',
@@ -36,8 +37,9 @@ export const TEXTOS = {
36
37
  vistaClienteT: 'What the client will see: nothing of yours, nothing inferred, no commands', claro: 'Light', oscuro: 'Dark', idioma: 'Language', vista: 'View',
37
38
  pista: 'Tap a zone to see what it holds', pista3d: 'Drag to turn it any way · double click: side view · each spark is a memory being used',
38
39
  piensa: 'See how it thinks', pararP: 'Stop', piensaT: 'Replays its latest lookups in memory, lighting up each zone it touched', masUsa: 'What it looks up most ({d} days):', sinUso: 'No usage recorded yet: it glows by what each zone holds.', nadaEncontro: 'found nothing', loUso: 'used it', noLoUso: 'did not use it', paso: '{i} of {n}',
39
- buscar: 'Ask the memory…', buscarL: 'Search the memory', semana: 'This week', nadaSemana: 'Nothing new in the last 7 days.',
40
+ buscar: 'Ask the memory…', buscarL: 'Search the memory', panelTitulo: 'Memory', panelOcultar: 'Hide panel', panelVer: 'Show panel', semana: 'This week', nadaSemana: 'Nothing new in the last 7 days.',
40
41
  sigueAbierto: 'Still open', todo: 'Everything it remembers', coincide: 'Matches',
42
+ salud: { t: 'Reliability', hechos: 'Facts', bateria: 'Battery (eval)', uso: 'Real use', sesion: 'Last session' },
41
43
  sinRes: 'Nothing in the memory for “{q}”. If it is not here, the memory does not know it.', zonaVacia: 'Nothing in this zone yet.',
42
44
  vacia: 'The memory is empty. It fills up by itself as you talk to the agent.', verMas: 'Show {n} more',
43
45
  quien: 'Who said it', desde: 'Since', usado: 'Used', enDevlog: 'In the devlog', historia: 'History', relacionado: 'Related', cambiar: 'To change it:', cerrar: 'Close details',
@@ -60,7 +62,7 @@ export const TEXTOS = {
60
62
  vistaClienteT: 'O que o cliente verá: nada teu, nada deduzido, sem comandos', claro: 'Claro', oscuro: 'Escuro', idioma: 'Idioma', vista: 'Vista',
61
63
  pista: 'Toca numa zona para ver o que guarda', pista3d: 'Arrasta para o rodar em qualquer direção · duplo clique: de lado · cada brilho é uma memória em uso',
62
64
  piensa: 'Ver como pensa', pararP: 'Parar', piensaT: 'Reproduz as suas últimas consultas à memória, acendendo cada zona que tocou', masUsa: 'O que mais consulta ({d} dias):', sinUso: 'Ainda não há uso registado: brilha conforme o que cada zona guarda.', nadaEncontro: 'não encontrou nada', loUso: 'usou', noLoUso: 'não usou', paso: '{i} de {n}',
63
- buscar: 'Pergunta à memória…', buscarL: 'Pesquisar na memória', semana: 'Esta semana', nadaSemana: 'Nada de novo nos últimos 7 dias.',
65
+ buscar: 'Pergunta à memória…', buscarL: 'Pesquisar na memória', panelTitulo: 'Memória', panelOcultar: 'Ocultar painel', panelVer: 'Ver painel', semana: 'Esta semana', nadaSemana: 'Nada de novo nos últimos 7 dias.',
64
66
  sigueAbierto: 'Continua em aberto', todo: 'Tudo o que lembra', coincide: 'O que coincide',
65
67
  sinRes: 'Nada na memória para «{q}». Se não está aqui, a memória não o sabe.', zonaVacia: 'Ainda não há nada nesta zona.',
66
68
  vacia: 'A memória está vazia. Enche-se sozinha quando falas com o agente.', verMas: 'Ver mais {n}',
@@ -84,7 +86,7 @@ export const TEXTOS = {
84
86
  vistaClienteT: 'Ce que verra le client : rien de toi, rien de déduit, aucune commande', claro: 'Clair', oscuro: 'Sombre', idioma: 'Langue', vista: 'Vue',
85
87
  pista: 'Touche une zone pour voir ce qu’elle garde', pista3d: 'Fais-le glisser pour le tourner dans tous les sens · double clic : de profil · chaque éclat est un souvenir utilisé',
86
88
  piensa: 'Voir comment il pense', pararP: 'Arrêter', piensaT: 'Rejoue ses dernières recherches dans la mémoire en allumant chaque zone touchée', masUsa: 'Ce qu’il consulte le plus ({d} jours) :', sinUso: 'Aucun usage enregistré pour l’instant : il brille selon ce que garde chaque zone.', nadaEncontro: 'n’a rien trouvé', loUso: 'l’a utilisé', noLoUso: 'ne l’a pas utilisé', paso: '{i} sur {n}',
87
- buscar: 'Demande à la mémoire…', buscarL: 'Chercher dans la mémoire', semana: 'Cette semaine', nadaSemana: 'Rien de nouveau ces 7 derniers jours.',
89
+ buscar: 'Demande à la mémoire…', buscarL: 'Chercher dans la mémoire', panelTitulo: 'Mémoire', panelOcultar: 'Masquer le panneau', panelVer: 'Afficher le panneau', semana: 'Cette semaine', nadaSemana: 'Rien de nouveau ces 7 derniers jours.',
88
90
  sigueAbierto: 'Toujours ouvert', todo: 'Tout ce dont elle se souvient', coincide: 'Ce qui correspond',
89
91
  sinRes: 'Rien dans la mémoire pour « {q} ». Si ce n’est pas ici, la mémoire ne le sait pas.', zonaVacia: 'Rien dans cette zone pour l’instant.',
90
92
  vacia: 'La mémoire est vide. Elle se remplit toute seule quand tu parles à l’agent.', verMas: 'Voir {n} de plus',
@@ -108,7 +110,7 @@ export const TEXTOS = {
108
110
  vistaClienteT: 'So sieht es der Kunde: nichts von dir, nichts Abgeleitetes, keine Befehle', claro: 'Hell', oscuro: 'Dunkel', idioma: 'Sprache', vista: 'Ansicht',
109
111
  pista: 'Tippe auf eine Zone, um zu sehen, was sie enthält', pista3d: 'Ziehen, um es in jede Richtung zu drehen · Doppelklick: Seitenansicht · jedes Aufblitzen ist eine genutzte Erinnerung',
110
112
  piensa: 'Sehen, wie es denkt', pararP: 'Stopp', piensaT: 'Spielt die letzten Abfragen im Gedächtnis ab und lässt jede berührte Zone aufleuchten', masUsa: 'Am häufigsten abgefragt ({d} Tage):', sinUso: 'Noch keine Nutzung erfasst: Es leuchtet nach dem, was jede Zone enthält.', nadaEncontro: 'nichts gefunden', loUso: 'genutzt', noLoUso: 'nicht genutzt', paso: '{i} von {n}',
111
- buscar: 'Frag das Gedächtnis…', buscarL: 'Im Gedächtnis suchen', semana: 'Diese Woche', nadaSemana: 'Nichts Neues in den letzten 7 Tagen.',
113
+ buscar: 'Frag das Gedächtnis…', buscarL: 'Im Gedächtnis suchen', panelTitulo: 'Gedächtnis', panelOcultar: 'Panel ausblenden', panelVer: 'Panel anzeigen', semana: 'Diese Woche', nadaSemana: 'Nichts Neues in den letzten 7 Tagen.',
112
114
  sigueAbierto: 'Noch offen', todo: 'Alles, woran es sich erinnert', coincide: 'Treffer',
113
115
  sinRes: 'Nichts im Gedächtnis zu „{q}“. Was hier nicht steht, weiß das Gedächtnis nicht.', zonaVacia: 'In dieser Zone ist noch nichts.',
114
116
  vacia: 'Das Gedächtnis ist leer. Es füllt sich von selbst, wenn du mit dem Agenten sprichst.', verMas: '{n} weitere anzeigen',
@@ -132,7 +134,7 @@ export const TEXTOS = {
132
134
  vistaClienteT: 'Ciò che vedrà il cliente: niente di tuo, niente di dedotto, nessun comando', claro: 'Chiaro', oscuro: 'Scuro', idioma: 'Lingua', vista: 'Vista',
133
135
  pista: 'Tocca una zona per vedere cosa contiene', pista3d: 'Trascinalo per girarlo in ogni direzione · doppio clic: di lato · ogni scintilla è un ricordo usato',
134
136
  piensa: 'Guarda come pensa', pararP: 'Ferma', piensaT: 'Riproduce le sue ultime consultazioni della memoria, accendendo ogni zona toccata', masUsa: 'Ciò che consulta di più ({d} giorni):', sinUso: 'Ancora nessun uso registrato: brilla in base a ciò che ogni zona contiene.', nadaEncontro: 'non ha trovato nulla', loUso: 'l’ha usato', noLoUso: 'non l’ha usato', paso: '{i} di {n}',
135
- buscar: 'Chiedi alla memoria…', buscarL: 'Cerca nella memoria', semana: 'Questa settimana', nadaSemana: 'Niente di nuovo negli ultimi 7 giorni.',
137
+ buscar: 'Chiedi alla memoria…', buscarL: 'Cerca nella memoria', panelTitulo: 'Memoria', panelOcultar: 'Nascondi pannello', panelVer: 'Mostra pannello', semana: 'Questa settimana', nadaSemana: 'Niente di nuovo negli ultimi 7 giorni.',
136
138
  sigueAbierto: 'Ancora aperto', todo: 'Tutto ciò che ricorda', coincide: 'Risultati',
137
139
  sinRes: 'Niente nella memoria per «{q}». Se non è qui, la memoria non lo sa.', zonaVacia: 'Ancora niente in questa zona.',
138
140
  vacia: 'La memoria è vuota. Si riempie da sola quando parli con l’agente.', verMas: 'Mostra altri {n}',
package/cortex/cortex.mjs CHANGED
@@ -156,6 +156,12 @@ h2 { font-size: 13px; text-transform: uppercase; letter-spacing: .16em; color: v
156
156
  .cambios li::before, .abiertos li::before { content: ""; width: 8px; height: 8px; margin-top: 8px; border-radius: 50%; background: var(--c); box-shadow: 0 0 10px var(--c); }
157
157
  .cambios small, .abiertos small { display: block; color: var(--suave); font-size: 12px; }
158
158
  .vacio { color: var(--suave); font-size: 14px; margin: 0; }
159
+ .salud { display: grid; gap: 10px; }
160
+ .salud-l { list-style: none; margin: 0; padding: 0; display: grid; gap: 7px; }
161
+ .salud-l li { display: flex; align-items: baseline; gap: 8px; font-size: 14px; border: 1px solid var(--borde); border-radius: var(--radio); padding: 8px 12px; background: var(--papel-alto); }
162
+ .salud-l li > span { color: var(--suave); }
163
+ .salud-l li > b { color: var(--texto); font-variant-numeric: tabular-nums; }
164
+ .salud-l li > small { color: var(--suave); margin-left: auto; text-align: right; font-size: 12px; }
159
165
  .lista { list-style: none; margin: 0; padding: 0; display: grid; gap: 8px; }
160
166
  .hecho { padding: 12px 16px 12px 18px; border-radius: 16px; background: var(--papel-alto); border: 1px solid var(--borde); display: grid; gap: 2px; cursor: pointer; position: relative; box-shadow: 0 1px 2px rgba(0,0,0,.25); transition: border-color .2s, transform .2s, box-shadow .2s; }
161
167
  .hecho::before { content: ""; position: absolute; left: 0; top: 14px; bottom: 14px; width: 3px; border-radius: 3px; background: var(--c); box-shadow: 0 0 12px var(--c); }
@@ -186,6 +192,26 @@ h2 { font-size: 13px; text-transform: uppercase; letter-spacing: .16em; color: v
186
192
  .mandos select, .busca input { font-size: 16px; }
187
193
  .panel { position: static; max-height: none; border-left: 0; border-top: 1px solid var(--linea); padding: 18px 16px 40px; }
188
194
  }
195
+ /* --- Panel: cabecera, colapso y pulido --------------------------------------------------------------- */
196
+ .panel { border-top-left-radius: 20px; box-shadow: inset 1px 1px 0 color-mix(in srgb, #fff 4%, transparent); }
197
+ [data-theme="light"] .panel { box-shadow: none; }
198
+ .panel-cab { display: flex; align-items: center; justify-content: space-between; gap: 12px; margin-bottom: 2px; }
199
+ .panel-tit { display: inline-flex; align-items: center; gap: 9px; font: 700 12px/1 var(--fuente-titulos); letter-spacing: .2em; text-transform: uppercase; color: var(--suave); }
200
+ .panel-tit::before { content: ""; width: 7px; height: 7px; border-radius: 50%; background: var(--foco); box-shadow: 0 0 10px color-mix(in srgb, var(--foco) 70%, transparent); }
201
+ .panel-cerrar, .panel-abrir { display: inline-flex; align-items: center; justify-content: center; width: 40px; height: 40px; min-width: 40px; border: 1px solid var(--borde); background: var(--papel-alto); border-radius: 12px; color: var(--suave); transition: background .2s, color .2s, border-color .2s, transform .2s; }
202
+ .panel-cerrar:hover, .panel-abrir:hover { color: var(--texto); border-color: var(--linea); background: var(--papel); }
203
+ .panel-cerrar svg, .panel-abrir svg { width: 17px; height: 17px; }
204
+ .panel > section { padding-top: 20px; border-top: 1px solid color-mix(in srgb, var(--linea) 55%, transparent); }
205
+ .busca { position: relative; display: block; }
206
+ .busca .lupa { position: absolute; left: 15px; top: 50%; transform: translateY(-50%); width: 17px; height: 17px; color: var(--suave); pointer-events: none; }
207
+ .busca input { padding-left: 44px; }
208
+ /* botón flotante para reabrir (solo visible cuando el panel está colapsado) */
209
+ .panel-abrir { position: fixed; top: 20px; right: 20px; z-index: 6; display: none; box-shadow: 0 10px 26px -14px rgba(0,0,0,.55); }
210
+ .panel-abrir:hover { transform: translateY(-1px); }
211
+ [data-panel="off"] .escena { grid-template-columns: minmax(0, 1fr); }
212
+ [data-panel="off"] .panel { display: none; }
213
+ [data-panel="off"] .panel-abrir { display: inline-flex; }
214
+ html[data-solo] .panel-abrir { display: none !important; }
189
215
  @media (prefers-reduced-motion: reduce) { * { transition: none !important; animation: none !important; } }
190
216
  `;
191
217
 
@@ -435,6 +461,15 @@ const APP = String.raw`
435
461
  });
436
462
  var pb = $('#piensa'); if (pb) pb.addEventListener('click', pensar);
437
463
 
464
+ // ---------------- Panel lateral colapsable (se recuerda por visor, sin tocar la memoria)
465
+ try { if (localStorage.getItem('cortex-panel') === 'off') raiz.setAttribute('data-panel', 'off'); } catch (e) {}
466
+ function panel(off) {
467
+ if (off) raiz.setAttribute('data-panel', 'off'); else raiz.removeAttribute('data-panel');
468
+ try { localStorage.setItem('cortex-panel', off ? 'off' : 'on'); } catch (e) {}
469
+ }
470
+ var ptog = $('#panel-toggle'); if (ptog) ptog.addEventListener('click', function () { panel(true); });
471
+ var pabr = $('#panel-abrir'); if (pabr) pabr.addEventListener('click', function () { panel(false); });
472
+
438
473
  // ---------------- 3D: un cerebro de verdad hecho de puntos, con neuronas que se encienden
439
474
  // Cada hemisferio es la UNIÓN de elipsoides (cuerpo, polo frontal, polo occipital, lóbulo temporal y cerebelo); de
440
475
  // cada uno se toman puntos de su superficie que no caen dentro de otro: queda la piel del cerebro. Entre hemisferios,
@@ -710,6 +745,20 @@ const esc = s => String(s).replace(/[&<>"]/g, c => ({ '&': '&amp;', '<': '&lt;',
710
745
  // JSON dentro de <script type="application/json">: «<» escapado, así ningún valor puede cerrar la etiqueta
711
746
  const json = o => JSON.stringify(o).replace(/</g, '\\u003c');
712
747
 
748
+ // F15-T8: panel de fiabilidad, server-rendered desde datos.salud (se lee sin JavaScript; las etiquetas se traducen por
749
+ // data-t, los números son neutros). Filas privadas (uso real, última sesión) con `solo-dueno`: ocultas en vista cliente.
750
+ function panelSalud(s, cliente, es) {
751
+ if (!s) return '';
752
+ const fam = Object.entries(s.hechos.porFamilia || {}).sort((a, b) => b[1] - a[1]).slice(0, 6).map(([k, v]) => `${k} ${v}`).join(' · ');
753
+ const fila = (clave, val, det, priv) => `<li${priv ? ' class="solo-dueno"' : ''}><span data-t="salud.${clave}">${es.salud[clave]}</span><b>${esc(String(val))}</b>${det ? `<small>${esc(det)}</small>` : ''}</li>`;
754
+ const filas = [fila('hechos', s.hechos.activos, fam)];
755
+ if (s.bateria) filas.push(fila('bateria', `${s.bateria.hit5}%`, `hit@5 · ${s.bateria.abstencion}% abst · ${s.bateria.ms} ms`));
756
+ if (!cliente && s.uso) filas.push(fila('uso', s.uso.precision != null ? `${s.uso.precision}%` : '—', `${s.uso.usados}/${s.uso.inyectados}`, true));
757
+ if (!cliente && s.ultimaSesion && s.ultimaSesion.fecha) filas.push(fila('sesion', s.ultimaSesion.guardo ? `+${s.ultimaSesion.guardo}` : '0',
758
+ `${s.ultimaSesion.fecha}${s.ultimaSesion.hechos.length ? ' · ' + s.ultimaSesion.hechos.map(h => String(h.dimension).split('.')[0]).join(' ') : ''}`, true));
759
+ return `<section class="salud" id="salud-s"><h2 data-t="salud.t">${es.salud.t}</h2><ul class="salud-l">${filas.join('')}</ul></section>`;
760
+ }
761
+
713
762
  export function htmlCortex(datos, { cli = null, idioma = null, soloCerebro = false } = {}) {
714
763
  const cliente = !!datos.cliente;
715
764
  const solo = !!(datos.soloCerebro || soloCerebro); // modo incrustable: solo el cerebro 3D, sin panel ni mandos
@@ -757,7 +806,12 @@ export function htmlCortex(datos, { cli = null, idioma = null, soloCerebro = fal
757
806
  </div>
758
807
  </section>
759
808
  <aside class="panel">
760
- <label class="busca"><span class="sr" data-t="buscarL">${es.buscarL}</span><input id="buscar" type="search" data-t-ph="buscar" placeholder="${es.buscar}" autocomplete="off"></label>
809
+ <div class="panel-cab">
810
+ <span class="panel-tit" data-t="panelTitulo">${es.panelTitulo}</span>
811
+ <button type="button" class="panel-cerrar" id="panel-toggle" data-t-aria="panelOcultar" data-t-title="panelOcultar" aria-label="${es.panelOcultar}" title="${es.panelOcultar}"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M9 6l6 6-6 6"/></svg></button>
812
+ </div>
813
+ <label class="busca"><span class="sr" data-t="buscarL">${es.buscarL}</span><svg class="lupa" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" aria-hidden="true"><circle cx="11" cy="11" r="7"/><path d="M21 21l-4-4"/></svg><input id="buscar" type="search" data-t-ph="buscar" placeholder="${es.buscar}" autocomplete="off"></label>
814
+ ${solo ? '' : panelSalud(datos.salud, cliente, es)}
761
815
  <section><h2 data-t="semana">${es.semana}</h2><ul class="cambios" id="cambios-l"></ul><p class="vacio" id="cambios-v" data-t="nadaSemana">${es.nadaSemana}</p></section>
762
816
  <section id="abiertos-s"><h2 data-t="sigueAbierto">${es.sigueAbierto}</h2><ul class="abiertos" id="abiertos-l"></ul></section>
763
817
  <section>
@@ -779,6 +833,7 @@ export function htmlCortex(datos, { cli = null, idioma = null, soloCerebro = fal
779
833
  </article>
780
834
  <p class="pie" id="pie"></p>
781
835
  </aside>
836
+ <button type="button" class="panel-abrir" id="panel-abrir" data-t-aria="panelVer" data-t-title="panelVer" aria-label="${es.panelVer}" title="${es.panelVer}"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M15 6l-6 6 6 6"/></svg></button>
782
837
  </div>
783
838
  <script type="application/json" id="datos-cortex">${json(D)}</script>
784
839
  <script type="application/json" id="textos-cortex">${json(TEXTOS)}</script>
package/install.mjs CHANGED
@@ -19,11 +19,13 @@
19
19
  import fs from 'node:fs';
20
20
  import os from 'node:os';
21
21
  import path from 'node:path';
22
- import { fileURLToPath } from 'node:url';
23
- import { esSenzu } from './src/lib.mjs'; // para el aviso de proyecto con Senzu
22
+ import { fileURLToPath, pathToFileURL } from 'node:url';
24
23
 
25
24
  const AQUI = path.dirname(fileURLToPath(import.meta.url));
26
- const SRC = path.join(AQUI, 'src'); // donde viven los hooks del núcleo (ruta absoluta)
25
+ // El núcleo vive en src/ (repo) o en hooks/ (cuando install.mjs viaja DENTRO del plugin): así `/corvus-install`
26
+ // puede instalar en un proyecto desde el plugin, sin npx.
27
+ const SRC = fs.existsSync(path.join(AQUI, 'src')) ? path.join(AQUI, 'src') : path.join(AQUI, 'hooks');
28
+ const { esSenzu } = await import(pathToFileURL(path.join(SRC, 'lib.mjs')).href); // para el aviso de proyecto con Senzu
27
29
  const CMDS_SRC = path.join(AQUI, 'commands'); // slash-command templates (/corvus-absorb)
28
30
  const CLI_SRC = path.join(AQUI, 'cli'); // el CLI de la memoria (corvusmem.mjs + subcomandos): se empaqueta para el guardado RÁPIDO (sin npx)
29
31
  const CORTEX_SRC = path.join(AQUI, 'cortex'); // el render del Cortex (cortex.mjs + cortex-text.mjs): se empaqueta para que --cortex funcione en local (sin npx)
@@ -141,16 +143,24 @@ function empaquetarPlugin(destino) {
141
143
  const ncli = copiarCli(dir);
142
144
  // 2c) el render del Cortex en <plugin>/cortex/: para que /corvus-cortex dibuje el cerebro en local, sin npx
143
145
  const ncx = copiarCortex(dir);
146
+ // 2d) el propio install.mjs en la raíz del plugin: para que /corvus-install instale en un proyecto desde el plugin
147
+ // (sin npx). Corre con el núcleo del propio plugin (hooks/) gracias a la resolución src/ || hooks/ de arriba.
148
+ fs.copyFileSync(path.join(AQUI, 'install.mjs'), path.join(dir, 'install.mjs'));
144
149
  // 3) slash commands (/corvus-absorb) in the plugin's commands/ dir
145
150
  let nc = 0;
146
151
  try {
147
152
  const cmds = fs.readdirSync(CMDS_SRC).filter(f => f.endsWith('.md'));
148
153
  if (cmds.length) { fs.mkdirSync(path.join(dir, 'commands'), { recursive: true }); for (const f of cmds) { fs.copyFileSync(path.join(CMDS_SRC, f), path.join(dir, 'commands', f)); nc++; } }
149
154
  } catch { /* no commands/ */ }
150
- // 4) plugin.json
151
- const plugin = { name: 'corvusmem', description: pkg.description || 'Memoria determinista, offline y sin dependencias para agentes de IA.', version: pkg.version || '0.0.0', author: { name: 'Peterson Sena' }, homepage: pkg.homepage || 'https://corvusmem.vercel.app', repository: (pkg.repository && pkg.repository.url) || 'https://github.com/petersonsenadevs/corvusmem', license: 'SEE LICENSE IN LICENSE' };
155
+ // 4b) icono del listado (cuervo sobre fondo oscuro): el directorio de Anthropic lo pide (PNG cuadrado < 2 MB).
156
+ const iconoSrc = path.join(AQUI, 'assets', 'icon.png');
157
+ let iconoCampo = undefined;
158
+ if (fs.existsSync(iconoSrc)) { fs.copyFileSync(iconoSrc, path.join(dir, '.claude-plugin', 'icon.png')); iconoCampo = '.claude-plugin/icon.png'; }
159
+ // 4) plugin.json — repository en https:// PURO (el directorio descarta git+…/.git); displayName + icon para el listado.
160
+ const repo = String((pkg.repository && pkg.repository.url) || 'https://github.com/petersonsenadevs/corvusmem').replace(/^git\+/, '').replace(/\.git$/, '');
161
+ const plugin = { name: 'corvusmem', displayName: 'Corvusmem', description: pkg.description || 'Memoria determinista, offline y sin dependencias para agentes de IA.', version: pkg.version || '0.0.0', author: { name: 'Peterson Sena (r3v3rs3)', url: 'https://dev.to/r3v3rs3' }, homepage: pkg.homepage || 'https://corvusmem.vercel.app', repository: repo, license: 'SEE LICENSE IN LICENSE', ...(iconoCampo ? { icon: iconoCampo } : {}) };
152
162
  fs.writeFileSync(path.join(dir, '.claude-plugin', 'plugin.json'), JSON.stringify(plugin, null, 2) + '\n');
153
- log(` [plugin] ${dir}: .claude-plugin/plugin.json + hooks/hooks.json + ${n} .mjs + ${ncli} cli + ${ncx} cortex${nc ? ` + ${nc} command(s)` : ''}`);
163
+ log(` [plugin] ${dir}: .claude-plugin/plugin.json + hooks/hooks.json + ${n} .mjs + ${ncli} cli + ${ncx} cortex${nc ? ` + ${nc} command(s)` : ''}${iconoCampo ? ' + icon' : ''}`);
154
164
  }
155
165
 
156
166
  // Genera, DENTRO del repo, el plugin committeable `plugins/corvusmem/` y el `.claude-plugin/marketplace.json` de la
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "corvusmem",
3
- "version": "0.5.1",
3
+ "version": "0.6.0",
4
4
  "description": "Deterministic, offline, zero-dependency memory for AI coding agents (Claude Code, Codex) and a standalone CLI.",
5
5
  "type": "module",
6
6
  "bin": {
@@ -11,15 +11,17 @@
11
11
  "cli/",
12
12
  "commands/",
13
13
  "cortex/",
14
+ "assets/icon.png",
14
15
  "install.mjs",
15
16
  "docs.md",
16
17
  "COMMERCIAL.md",
17
18
  "CHANGELOG.md"
18
19
  ],
19
20
  "scripts": {
20
- "test": "node tests/test-boundary.mjs && node tests/test-facts.mjs && node tests/test-hard-recall.mjs && node tests/test-install.mjs && node tests/test-import.mjs && node tests/test-plugin.mjs && node tests/test-parity.mjs && node tests/test-cortex-visual.mjs",
21
- "test:core": "node tests/test-boundary.mjs && node tests/test-facts.mjs && node tests/test-hard-recall.mjs && node tests/test-install.mjs && node tests/test-import.mjs && node tests/test-plugin.mjs && node tests/test-parity.mjs",
21
+ "test": "node tests/test-boundary.mjs && node tests/test-facts.mjs && node tests/test-hard-recall.mjs && node tests/test-install.mjs && node tests/test-import.mjs && node tests/test-plugin.mjs && node tests/test-parity.mjs && node tests/test-save-criterios.mjs && node tests/test-hecho-detector.mjs && node tests/test-extractor.mjs && node tests/test-extractor-integracion.mjs && node tests/test-recall-piso.mjs && node tests/test-health.mjs && node tools/eval-memoria/eval.mjs --gate && node tests/test-cortex-visual.mjs",
22
+ "test:core": "node tests/test-boundary.mjs && node tests/test-facts.mjs && node tests/test-hard-recall.mjs && node tests/test-install.mjs && node tests/test-import.mjs && node tests/test-plugin.mjs && node tests/test-parity.mjs && node tests/test-save-criterios.mjs && node tests/test-hecho-detector.mjs && node tests/test-extractor.mjs && node tests/test-extractor-integracion.mjs && node tests/test-recall-piso.mjs && node tests/test-health.mjs && node tools/eval-memoria/eval.mjs --gate",
22
23
  "bench:tokens": "node tools/eval-tokens.mjs",
24
+ "bench:precision": "node tools/eval-precision-inyeccion.mjs",
23
25
  "preversion": "npm run test:core",
24
26
  "prepublishOnly": "npm run test:core"
25
27
  },
@@ -49,6 +51,7 @@
49
51
  "url": "https://github.com/petersonsenadevs/corvusmem/issues"
50
52
  },
51
53
  "devDependencies": {
54
+ "@huggingface/transformers": "^4.3.2",
52
55
  "gpt-tokenizer": "^4.1.0"
53
56
  }
54
57
  }
@@ -0,0 +1,71 @@
1
+ // Corvusmem · author: Peterson Sena (r3v3rs3) · https://github.com/petersonsenadevs/corvusmem
2
+ // Extractor DETERMINISTA de hechos (F17-T8): de una frase con forma de hecho saca {dimension, valor, claves} sin LLM
3
+ // ni red, misma entrada → misma salida. Hoy esa destilación la hace el AGENTE a mano (live-memory solo detecta y
4
+ // empuja); eso lo hace inconsistente y es la raíz del bug de que un dato acabe en la dimensión o el almacén equivocados.
5
+ // Este módulo ADELANTA el trabajo SOLO donde la dimensión es inequívoca (ubicación personal, sede, herramienta); para
6
+ // lo ambiguo (p. ej. el coste de un proveedor) devuelve null y el agente decide como hasta ahora. Alta precisión,
7
+ // recall bajo: el mismo contrato que el detector esHechoGuardable (src/live-memory.mjs), del que es subconjunto.
8
+ // La dimensión y las claves pasan SIEMPRE por la convención del motor (dimensionConvencional/clavesConvencionales de
9
+ // facts.mjs), así el extractor produce exactamente lo que guardaría un agente cuidadoso: cero divergencia de formato.
10
+
11
+ import { dimensionConvencional, clavesConvencionales, normalizar } from './facts.mjs';
12
+ import { esHechoGuardable, PREGUNTA } from './live-memory.mjs';
13
+
14
+ // Gestores de paquetes y editores conocidos: si la herramienta usada es uno de estos, la dimensión es más fina que
15
+ // «proyecto.stack» (es una preferencia de utillaje). Listas cerradas y deterministas; lo que no esté cae a stack.
16
+ const GESTORES = new Set(['npm', 'pnpm', 'yarn', 'bun', 'pip', 'pipenv', 'poetry', 'pdm', 'composer', 'cargo', 'go', 'gem', 'bundler', 'maven', 'gradle']);
17
+ const EDITORES = new Set(['vscode', 'vs-code', 'vim', 'neovim', 'nvim', 'emacs', 'webstorm', 'phpstorm', 'pycharm', 'intellij', 'sublime', 'zed', 'cursor', 'nano', 'helix']);
18
+
19
+ // Limpia un valor capturado: espacios simples y sin puntuación de cierre colgando. Conserva mayúsculas (nombres propios).
20
+ const limpiarValor = s => String(s || '').replace(/\s+/g, ' ').replace(/[.,;:!?¿¡\s]+$/u, '').trim();
21
+ const esNombrePropio = s => /^\p{Lu}/u.test(String(s || '').trim());
22
+
23
+ // Cada regla: un patrón con UN grupo de captura (la entidad) y cómo mapearla a dimensión. El orden es el de precisión.
24
+ // Las de ubicación exigen nombre propio en el grupo (ya lo fuerza \p{Lu} en el patrón); la de herramienta decide la
25
+ // familia por la lista a la que pertenece el token.
26
+ const REGLAS = [
27
+ {
28
+ nombre: 'ubicacion-personal',
29
+ re: /\b(?:vivo|vive|vivimos|viven|viv[íi]a|resido|reside)\s+en\s+(\p{Lu}[\p{L}À-ɏ'’-]*(?:\s+\p{Lu}[\p{L}À-ɏ'’-]*)*)/u,
30
+ dim: () => 'identidad.ubicacion',
31
+ claves: v => ['ciudad', v],
32
+ },
33
+ {
34
+ nombre: 'sede-oficina',
35
+ re: /\b(?:la\s+oficina|la\s+sede|el\s+despacho)\b[^.?!\n]{0,24}?\best[aá]\s+en\s+(\p{Lu}[\p{L}À-ɏ'’-]*(?:\s+\p{Lu}[\p{L}À-ɏ'’-]*)*)/u,
36
+ dim: () => 'proyecto.sede',
37
+ claves: v => ['sede', 'oficina', v],
38
+ },
39
+ {
40
+ nombre: 'herramienta',
41
+ re: /\b(?:usamos|utilizamos|trabajamos\s+con|we\s+use|we\s+work\s+with)\s+([\p{L}@][\w.@/+-]{1,})/iu,
42
+ dim: v => {
43
+ const t = normalizar(v).replace(/[^\p{L}\p{N}-]/gu, '');
44
+ if (GESTORES.has(t)) return 'preferencia.gestor-paquetes';
45
+ if (EDITORES.has(t)) return 'preferencia.editor';
46
+ return 'proyecto.stack';
47
+ },
48
+ claves: v => [v],
49
+ },
50
+ ];
51
+
52
+ // Devuelve { dimension, valor, claves, fragmento, regla } canónico, o null si no hay un hecho de dimensión INEQUÍVOCA.
53
+ // Una pregunta nunca es un hecho (reusa el guardián del detector). Es un SUBCONJUNTO de esHechoGuardable: lo que este
54
+ // detecta pero el extractor no sabe dimensionar con seguridad, devuelve null (y el agente sigue destilándolo a mano).
55
+ export function extraerHecho(texto) {
56
+ const t = String(texto || '').trim();
57
+ if (!t || PREGUNTA.test(t)) return null;
58
+ for (const regla of REGLAS) {
59
+ const mm = regla.re.exec(t);
60
+ if (!mm) continue;
61
+ const valor = limpiarValor(mm[1]);
62
+ if (!valor) continue;
63
+ if (regla.nombre !== 'herramienta' && !esNombrePropio(valor)) continue;
64
+ let dimension;
65
+ try { dimension = dimensionConvencional(regla.dim(valor)).dimension; } catch { continue; }
66
+ const claves = clavesConvencionales(regla.claves(valor), dimension);
67
+ const fragmento = (esHechoGuardable(t) || mm[0]).replace(/\s+/g, ' ').trim().slice(0, 120);
68
+ return { dimension, valor, claves, fragmento, regla: regla.nombre };
69
+ }
70
+ return null;
71
+ }
@@ -9,7 +9,7 @@
9
9
 
10
10
  import fs from 'node:fs';
11
11
  import path from 'node:path';
12
- import { readHookInput, projectRoot, sessionFlag, sinTextoCitado, relDelProyecto, rutaNativa, ruta, rutaRel, rutaMemoriaUsuario, testOnce, rutaBuscador, editadosSesion } from './lib.mjs';
12
+ import { readHookInput, projectRoot, sessionFlag, sinTextoCitado, relDelProyecto, rutaNativa, ruta, rutaRel, rutaMemoriaUsuario, testOnce, rutaBuscador, editadosSesion, localeUI, msg } from './lib.mjs';
13
13
  import { palabras, palabraConPeso, todosLosHechos } from './facts.mjs';
14
14
 
15
15
  const p = readHookInput() || {};
@@ -50,6 +50,7 @@ if (evento === 'PostToolUse') {
50
50
 
51
51
  // ---------------- Stop: dos comprobaciones, cada una UNA vez por sesión, en un solo mensaje
52
52
  const root = projectRoot();
53
+ const lang = localeUI(root);
53
54
  const rev = leerRevision(flag);
54
55
  const cli = rutaBuscador(root).replace(/buscar\.mjs$/, 'memory.mjs');
55
56
  const motivos = [];
@@ -59,10 +60,9 @@ let peticiones = null;
59
60
  try { peticiones = JSON.parse(fs.readFileSync(sessionFlag(sid, 'peticiones'), 'utf8')); } catch { }
60
61
  const conversacion = Array.isArray(peticiones) && peticiones.filter(x => palabras(x && x.texto).filter(palabraConPeso).length >= 2).length >= 2;
61
62
  if (conversacion && !rev.revisada && testOnce(sid, 'hechos-guard')) {
62
- motivos.push('Revisa la memoria (en el idioma en que haya hablado el usuario): ¿ha dicho en esta sesión algo ESTABLE de sí o '
63
- + 'del proyecto (dónde vive, su stack, una preferencia, un límite, un cliente, un objetivo o un pendiente)? '
64
- + `Si sí: node ${cli} --guardar --dimension familia.tema --valor "…" --claves "…" (familia: identidad, preferencia, proyecto, objetivo, pendiente, restriccion, nota o aprendizaje; tema en castellano, sea cual sea el idioma de la conversación; claves también en inglés y en su idioma; que se entienda solo: nombres y fechas absolutas, no «mañana» ni «él»; con «creo que…», --duda; lo que deduces tú y no dijo, --fuente agente). `
65
- + `Si no: node ${cli} --nada. Las decisiones y reglas del proyecto van a MEMORIA.md (/recordar). No inventes hechos que el usuario no dijo.`);
63
+ motivos.push('Revisa la memoria (en el idioma en que haya hablado el usuario).' + msg('save.criterios', lang).replace(/\s+/g, ' ').trimEnd()
64
+ + ` Si va: node ${cli} --guardar --dimension familia.tema --valor "…" --claves "…" (familia: identidad, preferencia, proyecto, objetivo, pendiente, restriccion, nota o aprendizaje; tema en castellano, sea cual sea el idioma de la conversación; claves también en inglés y en su idioma; que se entienda solo: nombres y fechas absolutas, no «mañana» ni «él»; con «creo que…», --duda; lo que deduces tú y no dijo, --fuente agente). `
65
+ + `Si no hay nada que guardar: node ${cli} --nada. Las decisiones y reglas del proyecto van a MEMORIA.md (/recordar). No inventes hechos que el usuario no dijo.`);
66
66
  }
67
67
  // 2. Consolidar (F6-T3): si la sesión TRABAJÓ (3+ archivos tocados, sin contar la memoria ni el plan) y no guardó ningún
68
68
  // aprendizaje.*, lo aprendido pasa a conocimiento duradero, enlazado solo con la entrada del devlog de hoy.
package/src/facts.mjs CHANGED
@@ -1104,8 +1104,11 @@ export function datosCortex(root, { cliente = false, ahora = hoy(), dias = 7, en
1104
1104
  .map(h => ({ id: h.id, privado: privado(h) || undefined, tema: temaDe(h.dimension), valor: h.valor, zona: zonaDe(h), progreso: h.progreso || 'abierto', dias: Math.max(0, Math.floor((Date.parse(ahora) - Date.parse(h.creado)) / 864e5)) }));
1105
1105
  // el nombre del proyecto: el que sabe la memoria (proyecto.nombre) o, si no, el de la carpeta
1106
1106
  const nombre = actuales.find(h => h.dimension === 'proyecto.nombre');
1107
+ // F15-T8: salud en el panel. Con cliente, sin lo privado (uso real y última sesión): solo hechos y batería.
1108
+ const salud = datosSalud(root, { ahora });
1109
+ const saludVista = cliente ? { generado: salud.generado, hechos: salud.hechos, bateria: salud.bateria } : salud;
1107
1110
  return { proyecto: nombre ? nombre.valor : path.basename(path.resolve(root)), generado: ahora, cliente, zonas, cambios: cambios.slice(0, 20), abiertos: abiertosV,
1108
- actividad: actividadCortex(root, { cliente, ahora }) };
1111
+ actividad: actividadCortex(root, { cliente, ahora }), salud: saludVista };
1109
1112
  }
1110
1113
  // Cómo PIENSA (X-T10): del registro de uso real, qué zonas ha consultado el agente y cuánto. Cada recuerdo que llegó
1111
1114
  // pesa más cuanto más reciente (se reduce a la mitad cada 3 días), más si lo usó y menos si lo ignoró. Y la secuencia
@@ -1151,6 +1154,46 @@ export function apuntarInyeccion(root, { sid, origen, consulta, items = [] }, {
1151
1154
  function leerUso(root) {
1152
1155
  try { return fs.readFileSync(rutaUso(root), 'utf8').split(/\r?\n/).filter(Boolean).map(l => { try { return JSON.parse(l); } catch { return null; } }).filter(Boolean); } catch { return []; }
1153
1156
  }
1157
+ // F17-T9: la ESCALA del diario (y las decisiones) para darles un suelo ABSOLUTO proporcional a su tamaño. Los puntos
1158
+ // de search.mjs dependen del tamaño del devlog (~0,7 pequeño, ~38 grande), así que un suelo fijo rompería los diarios
1159
+ // pequeños. La escala = p90 del MEJOR acierto de diario por consulta en el historial real (recuerdo-uso.jsonl), que ya
1160
+ // se acumula solo. Sin historial suficiente → 0 (sin suelo: se comporta como antes; no se daña a un proyecto nuevo).
1161
+ const MIN_CONSULTAS_ESCALA = 20; // por debajo de esto no hay muestra para fiarse: no se pone suelo
1162
+ const MAX_LINEAS_ESCALA = 1000; // solo la historia RECIENTE: representa la escala ACTUAL del diario (que crece con el
1163
+ // tiempo) y acota el coste del hook (parsear 3000 líneas por mensaje era ~14 ms)
1164
+ function mejoresDiario(root) {
1165
+ let raw = ''; try { raw = fs.readFileSync(rutaUso(root), 'utf8'); } catch { return []; }
1166
+ const lineas = raw.split(/\r?\n/).filter(Boolean);
1167
+ const recientes = lineas.length > MAX_LINEAS_ESCALA ? lineas.slice(-MAX_LINEAS_ESCALA) : lineas;
1168
+ const mejores = [];
1169
+ for (const ln of recientes) {
1170
+ let l; try { l = JSON.parse(ln); } catch { continue; }
1171
+ if (!l || l.origen === 'consulta') continue;
1172
+ let mx = 0; for (const it of (l.items || [])) if ((it.fuente === 'devlog' || it.fuente === 'memoria') && it.puntuacion != null && it.puntuacion > mx) mx = it.puntuacion;
1173
+ if (mx > 0) mejores.push(mx);
1174
+ }
1175
+ return mejores;
1176
+ }
1177
+ export function escalaDiario(root) {
1178
+ const mejores = mejoresDiario(root);
1179
+ if (mejores.length < MIN_CONSULTAS_ESCALA) return 0;
1180
+ mejores.sort((a, b) => a - b);
1181
+ return mejores[Math.min(mejores.length - 1, Math.floor(mejores.length * 0.90))]; // p90
1182
+ }
1183
+ // F17-T9e: el SUELO del diario = fracción × escala, con la fracción ESCALADA POR CONFIANZA. Con poca historia (recién
1184
+ // pasado el mínimo) el suelo es suave (0,25); con mucha, firme (0,35). De-risk 018/022: en un proyecto maduro el suelo
1185
+ // aguanta más alto sin estropear la relación ruido:útil, pero a 0,35 fijo el proyecto pequeño sufría → más datos, más
1186
+ // confianza, listón más alto. Sin historial suficiente → 0 (sin suelo). Única fuente del suelo (la usan hook y bench).
1187
+ const FRAC_MIN = 0.25, FRAC_MAX = 0.35, N_FRAC_MAX = 200; // 0,25 en el mínimo (20) → 0,35 con ≥200 consultas de diario
1188
+ export function pisoDiario(root) {
1189
+ const mejores = mejoresDiario(root);
1190
+ const n = mejores.length;
1191
+ if (n < MIN_CONSULTAS_ESCALA) return 0;
1192
+ mejores.sort((a, b) => a - b);
1193
+ const escala = mejores[Math.min(n - 1, Math.floor(n * 0.90))];
1194
+ const t = Math.max(0, Math.min(1, (n - MIN_CONSULTAS_ESCALA) / (N_FRAC_MAX - MIN_CONSULTAS_ESCALA)));
1195
+ return (FRAC_MIN + (FRAC_MAX - FRAC_MIN) * t) * escala;
1196
+ }
1154
1197
  // Lo que dijo el agente, con su hora, de una conversación de Claude Code (JSONL). Formato desconocido → [].
1155
1198
  export function textosDelAgente(transcript) {
1156
1199
  let crudo = ''; try { crudo = fs.readFileSync(transcript, 'utf8'); } catch { return []; }
@@ -1239,6 +1282,40 @@ export function informeUso(root, { dias = 30, ahora = hoy() } = {}) {
1239
1282
  };
1240
1283
  }
1241
1284
 
1285
+ // F15-T8: la salud de la memoria en números, UNA sola fuente para `--health` (CLI) y el panel del Cortex. Todo sale
1286
+ // del propio registro del proyecto (hechos, uso real, última sesión). La batería (eval determinista) solo existe en el
1287
+ // repo —es una herramienta de desarrollo, no va en el paquete—: en una instalación, `bateria` es null (y se dice).
1288
+ export function datosSalud(root, { dias = 30, ahora = hoy() } = {}) {
1289
+ const todos = todosLosHechos(root).filter(h => h.estado !== 'invalidado');
1290
+ const activos = todos.filter(h => h.estado === 'activo');
1291
+ const porFamilia = {}, porDimension = {};
1292
+ for (const h of activos) { const i = h.dimension.indexOf('.'); const fam = i >= 0 ? h.dimension.slice(0, i) : h.dimension; porFamilia[fam] = (porFamilia[fam] || 0) + 1; porDimension[h.dimension] = (porDimension[h.dimension] || 0) + 1; }
1293
+ // F17-T4: efecto fan (ACT-R, S − ln fan): una pista con MUCHOS hechos hace cada uno menos recuperable (interferencia).
1294
+ // Aviso determinista para que el agente concrete la consulta; no toca el ranking. Umbral = 5 (igual que ABANICO).
1295
+ const UMBRAL_FAN = 5;
1296
+ const pistasSaturadas = Object.entries(porDimension).filter(([, n]) => n >= UMBRAL_FAN).sort((a, b) => b[1] - a[1])
1297
+ .map(([dimension, n]) => ({ dimension, hechos: n, interferencia: +Math.log(n).toFixed(2), aviso: `${n} hechos en «${dimension}»: concreta la pista para recuperar el que buscas` }));
1298
+ const uso = informeUso(root, { dias, ahora });
1299
+ let ultimaSesion = null;
1300
+ try {
1301
+ const s = JSON.parse(fs.readFileSync(rutaEstado(root), 'utf8'));
1302
+ const g = Array.isArray(s.hechosGuardados) ? s.hechosGuardados : [];
1303
+ ultimaSesion = { fecha: String(s.actualizado || '').slice(0, 10) || null, guardo: g.length, hechos: g.slice(0, 5).map(h => ({ dimension: h.dimension, valor: h.valor })), archivos: Array.isArray(s.editados) ? s.editados.length : 0 };
1304
+ } catch {}
1305
+ let bateria = null;
1306
+ try {
1307
+ const f = path.join(AQUI, '..', 'tools', 'eval-memoria', 'resultados.json');
1308
+ if (fs.existsSync(f)) { const r = JSON.parse(fs.readFileSync(f, 'utf8')); const g = r.global || {}; bateria = { fecha: r.fecha, hit5: g.hit5_inyectado, abstencion: g.abstencion, duplicados: g.duplicados_ok, ms: g.ms_por_consulta, consultas: g.consultas }; }
1309
+ } catch {}
1310
+ return {
1311
+ generado: ahora,
1312
+ hechos: { activos: activos.length, dudosos: todos.filter(h => h.estado === 'dudoso').length, historico: todos.filter(h => h.estado === 'sustituido' || h.estado === 'cerrado').length, abiertos: abiertos(root, { ahora }).length, porFamilia },
1313
+ pistasSaturadas,
1314
+ uso: uso.mensajes ? { dias, mensajes: uso.mensajes, inyectados: uso.inyectados, usados: uso.usados, ignorados: uso.ignorados, precision: uso.precision } : null,
1315
+ bateria, ultimaSesion,
1316
+ };
1317
+ }
1318
+
1242
1319
  // ---------------------------------------------------------------- léxico multilingüe de la convención (X-T8)
1243
1320
  // Para cada tema canónico, cómo se dice en ~20 idiomas (es, en, ca, pt, fr, de, it, nl, pl, tr, ru, uk, el, ja, zh, ko,
1244
1321
  // ar, he, hi, vi, sv). Va al ÍNDICE (no a lo guardado: vale también para lo que ya existe) y no cuenta para la longitud
@@ -1266,6 +1343,12 @@ export const LEXICO = {
1266
1343
  analitica: 'analytics analitica analytique statistiques analytik analisi analityka analitik аналитика аналітика αναλυτικά アナリティクス 分析 분석 تحليلات אנליטיקה एनालिटिक्स phan tich analys',
1267
1344
  lanzamiento: 'launch release lanzamiento llancament lancamento lancement markteinfuhrung lancio lancering premiera lansman запуск κυκλοφορία ローンチ 发布 출시 إطلاق השקה लॉन्च lansering',
1268
1345
  tests: 'tests testing pruebas proves testes essais testen testy testler тесты тести δοκιμές テスト 测试 테스트 اختبارات בדיקות परीक्षण tester',
1346
+ // F15-T5: conceptos que faltaban (el baseline los perdía por paráfrasis sin vocabulario compartido). Formas en
1347
+ // varios idiomas y conjugaciones frecuentes, para que la CONSULTA coincida con lo que el hecho ya dice.
1348
+ indentacion: 'indentation indent indents indented indentar indentado indento indentas indenta sangria sangrado sangrar sangro sangras sangra tabs tab tabulacion tabulaciones tabulador espacios whitespace einruckung inspringen wciecie rientro indentazione',
1349
+ oficina: 'office oficina officina sede seu bureau buro despacho workplace headquarters escritorio ufficio buero kantoor biuro',
1350
+ deploy: 'deploy deployment deployed deploying despliegue desplegar desplegamos desplegado publicar publico publicamos publicado publicacion publish publishing published release releasing lanzar produccion bereitstellung implantacio implantar',
1351
+ tarifa: 'rate fee fees charge charges charged charging cobra cobrar cobramos cobrado cobro paga pagar pago pricing bill billing honorarios tarifas tariff honoraire tariffa gebuhr',
1269
1352
  };
1270
1353
  const LEXICO_TOKENS = new Map(Object.entries(LEXICO).map(([t, s]) => [t, palabras(s)]));
1271
1354
  // Las palabras del léxico de un hecho (si su tema es de la convención); [] si no
package/src/lib.mjs CHANGED
@@ -175,6 +175,9 @@ export function ruta(root, nombre) { // 'devlog' | 'plan' | 'design-system' |
175
175
  // MEMORY is ALWAYS Corvus's own, in English, and never flips with Senzu's presence: .corvusmem/memory/. The store
176
176
  // never moves when Senzu is added or removed; Corvus is the memory owner and Senzu defers to it (Senzu-side hayCorvus).
177
177
  if (nombre === 'memoria') return path.join(root, CARPETA_CORVUS, MEM_DIR_EN);
178
+ // El Cortex es salida PROPIA de Corvus: vive SIEMPRE dentro de .corvusmem/cortex, nunca suelto en la raíz del
179
+ // proyecto (ni en senzu/), esté o no Senzu. Así no ensucia la raíz con una carpeta cortex/ aparte.
180
+ if (nombre === 'cortex') return path.join(root, CARPETA_CORVUS, 'cortex');
178
181
  const base = carpetaBase(root);
179
182
  const nombreReal = nombre;
180
183
  const nueva = path.join(root, base, nombreReal);
@@ -4,41 +4,115 @@
4
4
  // 2. Si la petición trae una REGLA o una CORRECCIÓN clara («no vuelvas a…», «te dije…», «a partir de ahora…»,
5
5
  // «siempre usa…»), pide al agente apuntarla antes de seguir (memoria del proyecto o del usuario) y deja una
6
6
  // marca: estado-sesion bloquea el cierre una vez si al final no está apuntada.
7
+ // 3. (F15-T3) Si la petición es una FRASE CON FORMA DE HECHO —un dato que servirá luego: una herramienta que se usa,
8
+ // una cifra con su concepto, una ubicación, una API nombrada— empuja a guardarlo (nudge suave, no bloquea) y deja
9
+ // la marca 'hecho-pendiente' para un recordatorio de cierre. Alta precisión, recall bajo: una PREGUNTA nunca es un
10
+ // hecho que guardar (así «¿cuánto paga…?» o «qué framework usamos…» no disparan). Antes perder uno que meter ruido.
7
11
  // Solo señales fuertes: «siempre» o «nunca» sueltos no cuentan (salen en cualquier frase).
8
12
 
9
13
  import fs from 'node:fs';
10
- import { readHookInput, sessionFlag, outHookJson, rutaMemoriaUsuario, projectRoot, rutaRel, esMensajeDelUsuario } from './lib.mjs';
11
-
12
- const p = readHookInput();
13
- const texto = p && typeof p.prompt === 'string' ? p.prompt.trim() : '';
14
- if (!texto || !esMensajeDelUsuario(texto)) process.exit(0); // lo de un subagente no es una corrección del usuario
15
- const sid = p.session_id ? String(p.session_id) : 'default';
16
- const corto = texto.replace(/\s+/g, ' ').slice(0, 200);
17
-
18
- // 1. últimas peticiones (las 5 últimas bastan para saber de qué iba la sesión)
19
- try {
20
- const f = sessionFlag(sid, 'peticiones');
21
- let previas = [];
22
- try { previas = JSON.parse(fs.readFileSync(f, 'utf8')); } catch {}
23
- previas.push({ t: new Date().toISOString(), texto: corto });
24
- fs.writeFileSync(f, JSON.stringify(previas.slice(-5)));
25
- } catch {}
26
-
27
- // 2. reglas y correcciones
28
- const REGLA = new RegExp([
14
+ import { pathToFileURL } from 'node:url';
15
+ import { readHookInput, sessionFlag, outHookJson, rutaMemoriaUsuario, projectRoot, rutaRel, esMensajeDelUsuario, localeUI, msg, rutaCliMemoria } from './lib.mjs';
16
+ import { extraerHecho } from './extractor.mjs'; // F17-T8c: destila la dimensión/valor/claves cuando es inequívoco (ciclo seguro: solo se usa en funciones)
17
+
18
+ // ---------------- Detectores (puros y exportables: los tests los llaman sin montar el hook) ----------------
19
+
20
+ // Reglas y correcciones del usuario (señal fuerte y duradera).
21
+ export const REGLA = new RegExp([
29
22
  'no vuelvas a', 'nunca m[aá]s', 'ya te (lo )?(he )?dicho', 'te (lo )?(he )?dicho', 'te dije', 'a partir de ahora',
30
23
  'de ahora en adelante', 'para la pr[oó]xima', 'recuerda que', 'acu[eé]rdate de', 'cada vez que', 'no me gusta que',
31
24
  'prefiero que', 'no quiero que', 'eso no era (para|lo)', 'otra vez lo mismo', 'siempre (usa|haz|pon|escribe|responde|commitea|crea|pregunta)',
32
25
  'nunca (uses|hagas|pongas|commitees|subas|toques|borres|escribas)', 'no (lo|me) (vuelvas|repitas)',
33
26
  ].join('|'), 'i');
34
- const m = REGLA.exec(texto);
35
- if (!m) process.exit(0);
36
- try { fs.writeFileSync(sessionFlag(sid, 'memoria-pendiente'), corto); } catch {}
37
- const root = projectRoot();
38
- outHookJson('UserPromptSubmit', {
39
- additionalContext: `[senzu] Esto parece una regla o una corrección del usuario («${m[0]}…»). Si es duradera, apúntala ANTES de seguir: `
40
- + `de este proyecto → ${rutaRel(root, 'devlog')}/MEMORIA.md («Reglas del cliente y del proyecto» o «Lo que no funcionó»); `
41
- + `de todos sus proyectos → ${rutaMemoriaUsuario().replace(/\\/g, '/')} (memoria del usuario). Si dudas cuál, pregúntale en una línea. `
42
- + 'Si solo era una corrección de este momento (no una regla), sigue sin apuntar nada y dilo al cerrar.',
43
- });
44
- process.exit(0);
27
+
28
+ // Una PREGUNTA no es un hecho que guardar. Marcadores en ES/EN, con o sin signos; incluye «que» sin tilde a propósito
29
+ // (preferimos abstenernos a arriesgar un falso positivo con «qué framework usamos…»). Es el guardián de la precisión.
30
+ // Nota: con acentos no se puede cerrar con \b (á/é no son «word char» ASCII, el \b falla tras ellas): lookarounds \p{L}.
31
+ export const PREGUNTA = /[?¿]|(?<![\p{L}])(qu[eé]|cu[aá]l(es)?|cu[aá]nto?s?|cu[aá]nta?s?|qui[eé]n(es)?|d[oó]nde|c[oó]mo|cu[aá]ndo|por\s+qu[eé]|which|what|how|where|who|whom|whose|when|why|do\s+we|does|can\s+(we|the|it|i|you)|could|should)(?![\p{L}])/iu;
32
+
33
+ // Frases con FORMA DE HECHO: afirmación con un dato reusable. Cada patrón exige el dato (herramienta, cifra con
34
+ // moneda, ubicación con nombre propio, API/endpoint/URL nombrado), no solo el verbo. Recall bajo, precisión alta.
35
+ const HECHOS = [
36
+ // herramienta/stack estable que se USA: «usamos X», «we use X», «trabajamos con X»
37
+ /\b(usamos|utilizamos|trabajamos\s+con|we\s+use|we\s+work\s+with)\s+[\p{L}@][\w.@/+-]{1,}/iu,
38
+ // dato externo con CIFRA y moneda: «… cobra/paga/cuesta … 600 €/$/eur»
39
+ /\b(paga|pagan|pagamos|cobra|cobran|cuesta|cuestan|charges?|pays?|costs?)\b[^.?!\n]{0,40}?(\d[\d.,]*\s*(€|\$|eur|usd|euros|d[oó]lares)|[€$]\s?\d)/iu,
40
+ // ubicación con nombre propio: «vivo/vive/vivía en Madrid», «resido en …»
41
+ /\b(vivo|vive|vivimos|viven|viv[íi]a|resido|reside)\s+en\s+\p{Lu}/u,
42
+ // sede/oficina en un sitio: «la oficina está en Bilbao», «la sede está en …»
43
+ /\b(la\s+oficina|la\s+sede|el\s+despacho)\b[^.?!\n]{0,24}?\best[aá](?![\p{L}])[^.?!\n]{0,12}?\ben\b\s*\p{Lu}/iu,
44
+ // servicio externo nombrado: «la API es/está en …», «el endpoint es …», «la URL es …»
45
+ /\b(la\s+api|el\s+endpoint|la\s+url|el\s+host|el\s+servidor|the\s+api|the\s+endpoint|the\s+url)\b[^.?!\n]{0,24}?\b(es|est[aá]\s+en|is|at)\b\s*[^\s.?!]{3,}/iu,
46
+ ];
47
+
48
+ // Devuelve el fragmento con forma de hecho (recortado) o null. Una pregunta nunca es un hecho.
49
+ export function esHechoGuardable(texto) {
50
+ const t = String(texto || '').trim();
51
+ if (!t || PREGUNTA.test(t)) return null;
52
+ for (const re of HECHOS) { const m = re.exec(t); if (m) return m[0].replace(/\s+/g, ' ').trim().slice(0, 120); }
53
+ return null;
54
+ }
55
+
56
+ // F17-T8c: el comando de guardado que el nudge le ofrece al agente. Si el extractor determinista dimensiona el hecho
57
+ // (ubicación, sede, herramienta), el comando va YA DESTILADO —dimensión/valor/claves rellenos, el agente solo revisa—;
58
+ // si no, el placeholder de siempre y el agente destila a mano. Así la clave deja de depender de que el agente acierte.
59
+ // Puro y exportable (el test lo llama sin montar el hook).
60
+ export function comandoGuardado(texto, cli) {
61
+ const sug = extraerHecho(texto);
62
+ // `cli` (rutaCliMemoria) YA trae el ejecutable completo (`node "…/corvusmem.mjs"` o `npx corvusmem`): no se le
63
+ // antepone otro «node» (eso daba el comando roto «node node …», bug preexistente que el cableado destapó).
64
+ if (sug) {
65
+ return `Si va, el comando ya destilado (revísalo y ajusta la dimensión/valor si no encaja): `
66
+ + `${cli} --guardar --dimension ${sug.dimension} --valor "${sug.valor}" --claves "${sug.claves.join(', ')}".`;
67
+ }
68
+ return `Si va: ${cli} --guardar --dimension familia.tema --valor "…" --claves "…" `
69
+ + `(familia: identidad, preferencia, proyecto, objetivo, pendiente, restriccion, nota o aprendizaje; `
70
+ + `claves también en inglés y en su idioma; nombres y fechas absolutas).`;
71
+ }
72
+
73
+ // ---------------- Hook (solo al ejecutarse como script; al importarlo para los tests, no corre) ----------------
74
+
75
+ if (import.meta.url === pathToFileURL(process.argv[1] || '').href) {
76
+ const p = readHookInput();
77
+ const texto = p && typeof p.prompt === 'string' ? p.prompt.trim() : '';
78
+ if (!texto || !esMensajeDelUsuario(texto)) process.exit(0); // lo de un subagente no es una corrección del usuario
79
+ const sid = p.session_id ? String(p.session_id) : 'default';
80
+ const corto = texto.replace(/\s+/g, ' ').slice(0, 200);
81
+
82
+ // 1. últimas peticiones (las 5 últimas bastan para saber de qué iba la sesión)
83
+ try {
84
+ const f = sessionFlag(sid, 'peticiones');
85
+ let previas = [];
86
+ try { previas = JSON.parse(fs.readFileSync(f, 'utf8')); } catch {}
87
+ previas.push({ t: new Date().toISOString(), texto: corto });
88
+ fs.writeFileSync(f, JSON.stringify(previas.slice(-5)));
89
+ } catch {}
90
+
91
+ const root = projectRoot();
92
+
93
+ // 2. reglas y correcciones (señal fuerte: bloquea el cierre si no queda apuntada)
94
+ const m = REGLA.exec(texto);
95
+ if (m) {
96
+ try { fs.writeFileSync(sessionFlag(sid, 'memoria-pendiente'), corto); } catch {}
97
+ outHookJson('UserPromptSubmit', {
98
+ additionalContext: `[senzu] Esto parece una regla o una corrección del usuario («${m[0]}…»). Si es duradera, apúntala ANTES de seguir: `
99
+ + `de este proyecto → ${rutaRel(root, 'devlog')}/MEMORIA.md («Reglas del cliente y del proyecto» o «Lo que no funcionó»); `
100
+ + `de todos sus proyectos → ${rutaMemoriaUsuario().replace(/\\/g, '/')} (memoria del usuario). Si dudas cuál, pregúntale en una línea. `
101
+ + 'Si solo era una corrección de este momento (no una regla), sigue sin apuntar nada y dilo al cerrar.',
102
+ });
103
+ process.exit(0);
104
+ }
105
+
106
+ // 3. frase con forma de hecho (alta precisión): empuja a guardar sin bloquear, y deja marca para el cierre
107
+ const h = esHechoGuardable(texto);
108
+ if (!h) process.exit(0);
109
+ try { fs.writeFileSync(sessionFlag(sid, 'hecho-pendiente'), corto); } catch {}
110
+ const lang = localeUI(root);
111
+ const cli = rutaCliMemoria(root);
112
+ outHookJson('UserPromptSubmit', {
113
+ additionalContext: `[senzu] Esto suena a un dato que puede servir la próxima vez («${h}»). ${msg('save.criterios', lang)} `
114
+ + comandoGuardado(texto, cli) + ' '
115
+ + 'Si era solo de este momento, sigue sin guardar.',
116
+ });
117
+ process.exit(0);
118
+ }
@@ -9,12 +9,15 @@ import fs from 'node:fs';
9
9
  import crypto from 'node:crypto';
10
10
  import { readHookInput, projectRoot, sessionFlag, outHookJson, esMensajeDelUsuario, localeUI, msg, rutaCliMemoria } from './lib.mjs';
11
11
  import { reclamarInyeccion } from './host.mjs';
12
- import { recuerdo, palabras, palabraConPeso, UMBRAL_RECUERDO, anotarUso, apuntarInyeccion, mapaMemoria, textoMapa, intencionTemporal } from './facts.mjs';
12
+ import { recuerdo, palabras, palabraConPeso, UMBRAL_RECUERDO, anotarUso, apuntarInyeccion, mapaMemoria, textoMapa, intencionTemporal, pisoDiario } from './facts.mjs';
13
13
 
14
14
  // Umbrales (se afinan con la evaluación de F4). Hechos: BM25 del motor (IDF suavizado, escala estable). Memoria y
15
15
  // devlog: los puntos de search.mjs dependen del tamaño del devlog (0,7 en uno pequeño, 38 en uno grande), así que el
16
16
  // umbral es RELATIVO al mejor de su fuente; el buscador ya no devuelve nada si no hay relación.
17
17
  const UMBRAL_HECHO = UMBRAL_RECUERDO, RELATIVO = 0.5, MAXIMO = 5; // el de hechos, compartido con la evaluación
18
+ // F17-T9: suelo ABSOLUTO para diario+decisiones (0,25–0,35 × escala, escalado por confianza; `pisoDiario` en facts.mjs
19
+ // es la única fuente). El relativo solo exige «ser el mejor de su fuente»; sin un suelo, el diario cuela entradas
20
+ // flojas cuando no hay nada bueno. Auto-calibrado del historial; sin historial suficiente → 0 (sin suelo, como antes).
18
21
 
19
22
  const p = readHookInput();
20
23
  const texto = p && typeof p.prompt === 'string' ? p.prompt.trim() : '';
@@ -39,8 +42,9 @@ const clave = x => crypto.createHash('md5').update(`${x.fuente}|${x.id}|${x.text
39
42
  const intencion = intencionTemporal(consulta);
40
43
  const todos = recuerdo(root, consulta.slice(0, 600), { limite: 10, historico: intencion === 'historical' ? 'auto' : false, futuro: intencion === 'future' ? 'auto' : false });
41
44
  const mejor = f => Math.max(0, ...todos.filter(x => x.fuente === f).map(x => x.puntuacion));
45
+ const PISO_DIARIO = pisoDiario(root); // F17-T9: suelo absoluto para diario+decisiones (0 si no hay historial)
42
46
  const elegidos = todos
43
- .filter(x => (x.fuente === 'hecho' ? x.puntuacion >= UMBRAL_HECHO : x.puntuacion > 0 && x.puntuacion >= RELATIVO * mejor(x.fuente)) && !ya.has(clave(x)))
47
+ .filter(x => (x.fuente === 'hecho' ? x.puntuacion >= UMBRAL_HECHO : x.puntuacion > 0 && x.puntuacion >= RELATIVO * mejor(x.fuente) && x.puntuacion >= PISO_DIARIO) && !ya.has(clave(x)))
44
48
  .sort((a, b) => (a.debil === true) - (b.debil === true)) // lo sólido delante; los roces de una palabra, detrás y marcados
45
49
  .slice(0, MAXIMO);
46
50
  // X-T4: se apunta lo que se inyecta (o el silencio) para medir el uso real; al cerrar se marca si sirvió
package/src/messages.mjs CHANGED
@@ -537,6 +537,12 @@ export const CAT = {
537
537
  en: ' SAVE what the user says that is stable (in any language): {cli} --save --dimension family.topic --value "…" --keys "term in English,in their language" (family: identity, preference, project, goal, pending, constraint, note, learning). Make it stand on its own: who or what by name and an absolute date («Marco Bianchi, the photographer, charges 600 €», not «charges 600 €»; «on 2026-10-15», not «tomorrow»). With «I think…», --doubt; what you infer yourself, --source agent.',
538
538
  es: ' GUARDA lo estable que diga el usuario (en el idioma que sea): {cli} --guardar --dimension familia.tema --valor "…" --claves "término en inglés,en su idioma" (familia: identidad, preferencia, proyecto, objetivo, pendiente, restriccion, nota, aprendizaje). Que se entienda solo: quién o qué con su nombre y fecha absoluta («Marco Bianchi, el fotógrafo, cobra 600 €», no «cobra 600 €»; «el 15-10», no «mañana»). Con «creo que…», --duda; lo que deduces tú, --fuente agente.',
539
539
  },
540
+ // F15-T2: la VARA de qué guardar, en una sola fuente (la usan el inicio de sesión y el aviso de cierre), para que
541
+ // agentes distintos guarden lo mismo. Concreta y en positivo: "guarda si…", no "¿dijo algo estable?".
542
+ 'save.criterios': {
543
+ en: ' Save if something came up this session that will matter NEXT time (to you or a teammate): a decision made, a limit or constraint discovered, a stable user preference, an external fact with a name or figure (client, price, URL, path), a gotcha that cost time and its cause, or a goal or pending item. The bar: would you need it again and is it not already in the code? Then save it. Routine work and this-moment-only details are NOT saved.',
544
+ es: ' Guarda si en esta sesión salió algo que servirá la PRÓXIMA vez (a ti o a un compañero): una decisión tomada, un límite o restricción descubierto, una preferencia estable del usuario, un dato externo con nombre o cifra (cliente, precio, URL, ruta), un tropiezo que costó tiempo y su causa, o un objetivo o pendiente. La vara: ¿lo necesitarías otra vez y no está ya en el código? Entonces va. El trabajo rutinario y lo de este momento NO se guardan.',
545
+ },
540
546
  'start.prev': {
541
547
  en: '- Previous session ({when}): {parts}. If the user says «continue» or /resume, pick up from there; otherwise do not mention it.',
542
548
  es: '- Sesión anterior ({when}): {parts}. Si el usuario dice «sigue» o /retomar, continúa desde ahí; si no, no lo menciones.',
@@ -51,6 +51,7 @@ try {
51
51
  L.push(msg('start.map.intro', lang));
52
52
  L.push(mapa.hechos ? textoMapa(mapa) : msg('start.map.empty', lang));
53
53
  L.push(msg('start.map.consult', lang, { cli }));
54
+ L.push(msg('save.criterios', lang)); // F15-T2: la vara (qué guardar), antes de la sintaxis del comando
54
55
  L.push(msg('start.map.save', lang, { cli }));
55
56
  } catch { }
56
57
  // En qué se quedó la sesión anterior (session-state): para seguir sin que el usuario tenga que contarlo.
@@ -66,18 +66,36 @@ if (evento === 'Stop') try {
66
66
  }
67
67
  } catch {}
68
68
 
69
- // 2. al cerrar: ¿quedó apuntada la regla o corrección del usuario?
69
+ // 2. al cerrar: ¿quedó apuntado lo que dijo el usuario?
70
70
  if (evento !== 'Stop') process.exit(0);
71
- const marca = sessionFlag(sid, 'memoria-pendiente');
72
- if (!fs.existsSync(marca)) process.exit(0);
73
- let desde = 0; try { desde = fs.statSync(marca).mtimeMs; } catch {}
74
71
  const mtime = f => { try { return fs.statSync(f).mtimeMs; } catch { return 0; } };
75
- const apuntada = Math.max(memoriaProyecto(root).mtime, mtime(path.join(ruta(root, 'devlog'), 'MEMORIA-historico.md')), mtime(rutaMemoriaUsuario())) >= desde;
76
- if (apuntada) process.exit(0);
77
- const dijo = (() => { try { return fs.readFileSync(marca, 'utf8'); } catch { return ''; } })();
78
- const razon = `[senzu] El usuario dio una regla o una corrección en esta sesión («${dijo.slice(0, 120)}») y no está en la memoria. `
79
- + `Apúntala: de este proyecto → ${rutaRel(root, 'devlog')}/MEMORIA.md; de todos sus proyectos → ${rutaMemoriaUsuario().replace(/\\/g, '/')}. `
80
- + 'Si no era una regla duradera, dilo en una línea y cierra.';
81
- if (p.stop_hook_active !== true && testOnce(sid, 'stop-recordar')) process.stdout.write(JSON.stringify({ decision: 'block', reason: razon }) + '\n');
82
- else process.stdout.write(JSON.stringify({ systemMessage: razon }) + '\n');
72
+
73
+ // 2a. regla o corrección pendiente → bloquea UNA vez (es una instrucción del usuario: la vara más alta).
74
+ const marca = sessionFlag(sid, 'memoria-pendiente');
75
+ if (fs.existsSync(marca)) {
76
+ let desde = 0; try { desde = fs.statSync(marca).mtimeMs; } catch {}
77
+ const apuntada = Math.max(memoriaProyecto(root).mtime, mtime(path.join(ruta(root, 'devlog'), 'MEMORIA-historico.md')), mtime(rutaMemoriaUsuario())) >= desde;
78
+ if (!apuntada) {
79
+ const dijo = (() => { try { return fs.readFileSync(marca, 'utf8'); } catch { return ''; } })();
80
+ const razon = `[senzu] El usuario dio una regla o una corrección en esta sesión («${dijo.slice(0, 120)}») y no está en la memoria. `
81
+ + `Apúntala: de este proyecto → ${rutaRel(root, 'devlog')}/MEMORIA.md; de todos sus proyectos → ${rutaMemoriaUsuario().replace(/\\/g, '/')}. `
82
+ + 'Si no era una regla duradera, dilo en una línea y cierra.';
83
+ if (p.stop_hook_active !== true && testOnce(sid, 'stop-recordar')) process.stdout.write(JSON.stringify({ decision: 'block', reason: razon }) + '\n');
84
+ else process.stdout.write(JSON.stringify({ systemMessage: razon }) + '\n');
85
+ process.exit(0);
86
+ }
87
+ }
88
+
89
+ // 2b. (F15-T3) frase con forma de hecho sin guardar → recordatorio SUAVE, NUNCA bloquea (systemMessage).
90
+ // Si la sesión guardó algún hecho (facts.jsonl), editó MEMORIA.md o la memoria del usuario, se calla: ya hubo registro.
91
+ const marcaHecho = sessionFlag(sid, 'hecho-pendiente');
92
+ if (fs.existsSync(marcaHecho)) {
93
+ let desdeH = 0; try { desdeH = fs.statSync(marcaHecho).mtimeMs; } catch {}
94
+ const guardado = Math.max(memoriaProyecto(root).mtime, mtime(rutaHechos(root)), mtime(rutaMemoriaUsuario())) >= desdeH;
95
+ if (!guardado && testOnce(sid, 'stop-hecho')) {
96
+ const dijoH = (() => { try { return fs.readFileSync(marcaHecho, 'utf8'); } catch { return ''; } })();
97
+ process.stdout.write(JSON.stringify({ systemMessage: `[senzu] En esta sesión salió un dato que puede servir la próxima vez («${dijoH.slice(0, 100)}») y no está guardado. `
98
+ + 'Si vale para la próxima vez, guárdalo (node … --guardar --dimension familia.tema --valor "…"); si era solo de este momento, déjalo.' }) + '\n');
99
+ }
100
+ }
83
101
  process.exit(0);