wendkeep 0.68.6 → 0.70.0

package/CHANGELOG.md

@@ -4,6 +4,29 @@ All notable changes to **wendkeep** are documented here. Format based on
 [Keep a Changelog](https://keepachangelog.com/en/1.1.0/); this project follows
 [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.70.0] — 2026-08-17
+
+### Added
+
+- **Observer local multi-projeto.** O WendKeep agora expõe snapshots sanitizados, ingestão HTTP
+  loopback, índice append-only reconstruível, CLI `observer`, outbox fail-open nos hooks e um
+  compose Docker que persiste somente a projeção; os vaults locais continuam sendo a autoridade.
+
+### Fixed
+
+- **Modelos research preview agora são distinguidos de modelos desconhecidos.** O Spark é
+  reconhecido sem preço inventado, o `doctor` mantém o custo não estimado e a cobertura de
+  preços passa a ser validada por sensor crítico.
+
+## [0.69.0] — 2026-08-16
+
+### Added
+
+- **A Shared Project Memory v2 preserva handoffs estruturados entre providers.** Stop publica
+  objetivo, entrega, restrições, decisões, próximas ações, bloqueios e riscos com `work_session_id`;
+  CORE continua manual com cap 40/alerta 35, e status/validate-memory diagnosticam cobertura
+  semântica sem expor valores privados.
+
 ## [0.68.6] — 2026-08-16
 
 ### Fixed

package/README.en.md

@@ -85,9 +85,10 @@ Decisions, dead ends, the reason you chose X over Y — gone next session. The p
 | **Capture** — every turn, on disk | `SessionStart` / `Stop` hooks write each session to a dated Markdown note: prompts, iterations, files touched, wikilinks. |
 | **Derive** — decisions, bugs, learnings | Pulled from the transcript into their own notes, backlinked to the session. Your history becomes navigable, not archival. |
 | **Recall** — injected back | Canonical `CORE` + operational `SHARED_MEMORY`, with explicit budgets, are injected on `startup`, `/clear`, and `/compact`; `DIGEST` remains a deep-recall index and legacy fallback. |
-| **Cost** — what it all cost | Per‑model, cache‑aware token pricing per session — plus `cost --trend` with a run‑rate projection across the whole vault. |
+| **Cost** — what it all cost | Per‑model, cache‑aware token pricing per session — plus `cost --trend` with a run‑rate projection across the whole vault; research previews without a final rate remain unestimated. |
 | **Multi‑agent** — one vault, both agents | `init` wires the session hooks into `.claude/settings.json` *and* `.codex/hooks.json`, and every note is tagged with the agent that wrote it: Claude Code is detected from its environment, anything else is recorded as Codex. One shared graph, whichever agent you are in. |
 | **Local‑first** — no cloud, no account | Everything is plain Markdown on your disk. An optional MCP server (`@bitbonsai/mcpvault`) lets the agent read/write the vault. |
+| **Local Observer** — many projects, one view | `wendkeep observer` keeps a local HTTP index of sanitized, idempotent snapshots; vaults remain local, the container does not mount them, and unavailable hooks use an outbox without blocking the session. |
 
 ## Requirements
 
@@ -110,7 +111,7 @@ npx wendkeep init
 
 1. Create the vault folder taxonomy and a templated `README.md` (default vault: `<project>/.<project-name>-vault`, e.g. `.MyApp-vault`; override with `--vault`).
 2. Write a provider-neutral **`.wendkeep.json`** binding at the project root and a matching `.brain/PROJECT.json` marker in the vault, then merge the session hooks into **`.claude/settings.json`**. The binding is provider-neutral by design: any agent resolves the same vault from its session `cwd`, with no machine-global environment variable. Older registrations already in `.claude/settings.json` are adopted automatically.
-3. Wire the Codex hooks in **`.codex/hooks.json`** — eight of the twelve: `brain-inject` + `session-start` on `SessionStart`, `session-ensure` + `change-context` on `UserPromptSubmit`, `session-stop` + `change-nag` on `Stop`, `subagent-stop` on `SubagentStop`, and `change-guard` on `PreToolUse` for `Bash`, `exec_command`, `apply_patch`, and mutable MCP tools, always in the `npx wendkeep hook <name>` form. The guard accepts object, raw-string, and argv Codex payloads; before a mutation it compares the session with the project, Git root, remote, branch, and worktree, denying missing or divergent targets. The other four stay out because Codex offers no equivalent payload, tool, or event: `change-warn` (no reliable `tool_input.file_path`), `plan-capture` (no `ExitPlanMode`), `decision-capture` (`AskUserQuestion` is Claude-only), and `task-log` (`TaskCompleted` is not in Codex's event enum). Codex scope blocks use `permissionDecision: "deny"`; `ask` is never emitted in `PreToolUse`. The merge remains non-destructive, preserves third-party hooks, and migrates legacy `timeout` to `timeoutSec`. **Codex enumerates every hook as untrusted and runs none until you approve the “Hooks need review” prompt at startup — `init` cannot pre-approve them**.
+3. Wire the Codex hooks in **`.codex/hooks.json`** — ten compatible entries: `brain-inject` + `session-start` + `observer-publish` on `SessionStart`, `session-ensure` + `change-context` on `UserPromptSubmit`, `session-stop` + `observer-publish` + `change-nag` on `Stop`, `subagent-stop` on `SubagentStop`, and `change-guard` on `PreToolUse` for `Bash`, `exec_command`, `apply_patch`, and mutable MCP tools, always in the `npx wendkeep hook <name>` form. `observer-publish` only publishes a sanitized, fail-open projection; it does not replace the local lifecycle. The guard accepts object, raw-string, and argv Codex payloads; before a mutation it compares the session with the project, Git root, remote, branch, and worktree, denying missing or divergent targets. The other four stay out because Codex offers no equivalent payload, tool, or event: `change-warn` (no reliable `tool_input.file_path`), `plan-capture` (no `ExitPlanMode`), `decision-capture` (`AskUserQuestion` is Claude-only), and `task-log` (`TaskCompleted` is not in Codex's event enum). Codex scope blocks use `permissionDecision: "deny"`; `ask` is never emitted in `PreToolUse`. The merge remains non-destructive, preserves third-party hooks, and migrates legacy `timeout` to `timeoutSec`. **Codex enumerates every hook as untrusted and runs none until you approve the “Hooks need review” prompt at startup — `init` cannot pre-approve them**.
 4. Add the **`wendkeep-vault`** MCP server to `.mcp.json` so the agent can read/write the vault. Skip with `--no-mcp` — e.g. when the agent already has a vault MCP. (`--no-mcp` skips *only wendkeep's own* MCP; companion MCPs still follow `--companions`.)
 5. Offer to pin **companion** plugins/MCP (multi-choice; **none** pre-checked — wendkeep is a neutral harness and presumes no third-party plugin). Each is wired the most agent-agnostic way it supports:
    - **`context-mode`** — context optimizer + FTS5 memory, wired as a Claude Code plugin. It ships its own MCP server, so wendkeep deliberately adds no `.mcp.json` entry (registering both cold-started two servers at once). On non-Claude agents, add the MCP by hand: `npx -y context-mode`.
@@ -235,6 +236,7 @@ The README is the map; the guides provide syntax, options, exit codes, examples,
 | **Notes and knowledge** | BUG/APR/ADR, repairs, renumbering, lessons, and dashboard | [Notes and knowledge](https://github.com/rogersialves/wendkeep/blob/main/docs/en/commands/notes-and-knowledge.md) |
 | **Costs and observability** | safe dry-run, tri-state, aggregation, trends, and historical rebuild | [Costs and observability](https://github.com/rogersialves/wendkeep/blob/main/docs/en/commands/costs-and-observability.md) |
 | **Maintenance and diagnostics** | doctor, frontier/manifest freshness, drift, version, and help | [Maintenance and diagnostics](https://github.com/rogersialves/wendkeep/blob/main/docs/en/commands/maintenance-and-diagnostics.md) |
+| **Local Observer** | `observer serve`, registration, snapshots, outbox, and multi-project index | [Local Observer](https://github.com/rogersialves/wendkeep/blob/main/docs/en/commands/observer.md) |
 
 Operations that deserve step-by-step guidance: [verify and exits 0/1/2](https://github.com/rogersialves/wendkeep/blob/main/docs/en/commands/verify.md),
 [legacy-memory migration](https://github.com/rogersialves/wendkeep/blob/main/docs/en/commands/memory-migration.md), and
@@ -357,7 +359,9 @@ Codex uses `session_id`/`turn_id` plus transcript order, with no artificial caus
 
 ### Injection and budgets
 
-`brain-inject` delivers the same revision/hash on `startup`, `/clear`, and `/compact` `SessionStart` events, always placing CORE and SHARED before change context. The full envelope is capped at 24 KiB; CORE reserves up to 4 KiB, SHARED up to 6 KiB, and each line is capped at 320 characters. Under pressure, lessons are removed first, then non-current changes. CORE and SHARED are never prefix-sliced: a missing, invalid, or over-budget layer becomes a visible, repairable `<wk_memory_error>`.
+`CORE.md` is the only manual layer: it accepts up to 40 lines, warns from 35, keeps a 4 KiB ceiling, and caps each line at 320 characters. `SHARED_MEMORY.md` is generated exclusively by the projector and ledger; never edit it to repair state. `brain-inject` delivers the same revision/hash on `startup`, `/clear`, and `/compact` `SessionStart` events, always placing CORE and SHARED before change context. The full envelope is capped at 24 KiB; SHARED reserves up to 6 KiB. Under pressure, lessons are removed first, then non-current changes. CORE and SHARED are never prefix-sliced: a missing, invalid, or over-budget layer becomes a visible, repairable `<wk_memory_error>`.
+
+`memory status --gate` and `validate-memory --vault` also check semantic coverage: they report a code, counts, and active/projected/missing keys. An empty v2 bundle is neutral; a missing projectable event, placeholders as the only content, or an unresolved decision link becomes an explicit degraded/blocking diagnosis without printing memory values.
 
 `DIGEST.md` is no longer the operational handoff: it remains the `/brain-recall` bridge and legacy-vault fallback. A vault without SHARED receives CORE+DIGEST with a deprecation warning; migrate during the compatibility window:
 

package/README.md

@@ -85,9 +85,10 @@ Decisions, dead ends, the reason you chose X over Y — gone next session. The p
 | **Capture** — every turn, on disk | `SessionStart` / `Stop` hooks write each session to a dated Markdown note: prompts, iterations, files touched, wikilinks. |
 | **Derive** — decisions, bugs, learnings | Pulled from the transcript into their own notes, backlinked to the session. Your history becomes navigable, not archival. |
 | **Recall** — injected back | Canonical `CORE` + operational `SHARED_MEMORY`, with explicit budgets, are injected on `startup`, `/clear`, and `/compact`; `DIGEST` remains a deep-recall index and legacy fallback. |
-| **Cost** — what it all cost | Per‑model, cache‑aware token pricing per session — plus `cost --trend` with a run‑rate projection across the whole vault. |
+| **Cost** — what it all cost | Per‑model, cache‑aware token pricing per session — plus `cost --trend` with a run‑rate projection across the whole vault; research previews without a final rate remain unestimated. |
 | **Multi‑agent** — one vault, both agents | `init` wires the session hooks into `.claude/settings.json` *and* `.codex/hooks.json`, and every note is tagged with the agent that wrote it: Claude Code is detected from its environment, anything else is recorded as Codex. One shared graph, whichever agent you are in. |
 | **Local‑first** — no cloud, no account | Everything is plain Markdown on your disk. An optional MCP server (`@bitbonsai/mcpvault`) lets the agent read/write the vault. |
+| **Local Observer** — many projects, one view | `wendkeep observer` keeps a local HTTP index of sanitized, idempotent snapshots; vaults remain local, the container does not mount them, and unavailable hooks use an outbox without blocking the session. |
 
 ## Requirements
 
@@ -110,7 +111,7 @@ npx wendkeep init
 
 1. Create the vault folder taxonomy and a templated `README.md` (default vault: `<project>/.<project-name>-vault`, e.g. `.MyApp-vault`; override with `--vault`).
 2. Write a provider-neutral **`.wendkeep.json`** binding at the project root and a matching `.brain/PROJECT.json` marker in the vault, then merge the session hooks into **`.claude/settings.json`**. The binding is provider-neutral by design: any agent resolves the same vault from its session `cwd`, with no machine-global environment variable. Older registrations already in `.claude/settings.json` are adopted automatically.
-3. Wire the Codex hooks in **`.codex/hooks.json`** — eight of the twelve: `brain-inject` + `session-start` on `SessionStart`, `session-ensure` + `change-context` on `UserPromptSubmit`, `session-stop` + `change-nag` on `Stop`, `subagent-stop` on `SubagentStop`, and `change-guard` on `PreToolUse` for `Bash`, `exec_command`, `apply_patch`, and mutable MCP tools, always in the `npx wendkeep hook <name>` form. The guard accepts object, raw-string, and argv Codex payloads; before a mutation it compares the session with the project, Git root, remote, branch, and worktree, denying missing or divergent targets. The other four stay out because Codex offers no equivalent payload, tool, or event: `change-warn` (no reliable `tool_input.file_path`), `plan-capture` (no `ExitPlanMode`), `decision-capture` (`AskUserQuestion` is Claude-only), and `task-log` (`TaskCompleted` is not in Codex's event enum). Codex scope blocks use `permissionDecision: "deny"`; `ask` is never emitted in `PreToolUse`. The merge remains non-destructive, preserves third-party hooks, and migrates legacy `timeout` to `timeoutSec`. **Codex enumerates every hook as untrusted and runs none until you approve the “Hooks need review” prompt at startup — `init` cannot pre-approve them**.
+3. Wire the Codex hooks in **`.codex/hooks.json`** — ten compatible entries: `brain-inject` + `session-start` + `observer-publish` on `SessionStart`, `session-ensure` + `change-context` on `UserPromptSubmit`, `session-stop` + `observer-publish` + `change-nag` on `Stop`, `subagent-stop` on `SubagentStop`, and `change-guard` on `PreToolUse` for `Bash`, `exec_command`, `apply_patch`, and mutable MCP tools, always in the `npx wendkeep hook <name>` form. `observer-publish` only publishes a sanitized, fail-open projection; it does not replace the local lifecycle. The guard accepts object, raw-string, and argv Codex payloads; before a mutation it compares the session with the project, Git root, remote, branch, and worktree, denying missing or divergent targets. The other four stay out because Codex offers no equivalent payload, tool, or event: `change-warn` (no reliable `tool_input.file_path`), `plan-capture` (no `ExitPlanMode`), `decision-capture` (`AskUserQuestion` is Claude-only), and `task-log` (`TaskCompleted` is not in Codex's event enum). Codex scope blocks use `permissionDecision: "deny"`; `ask` is never emitted in `PreToolUse`. The merge remains non-destructive, preserves third-party hooks, and migrates legacy `timeout` to `timeoutSec`. **Codex enumerates every hook as untrusted and runs none until you approve the “Hooks need review” prompt at startup — `init` cannot pre-approve them**.
 4. Add the **`wendkeep-vault`** MCP server to `.mcp.json` so the agent can read/write the vault. Skip with `--no-mcp` — e.g. when the agent already has a vault MCP. (`--no-mcp` skips *only wendkeep's own* MCP; companion MCPs still follow `--companions`.)
 5. Offer to pin **companion** plugins/MCP (multi-choice; **none** pre-checked — wendkeep is a neutral harness and presumes no third-party plugin). Each is wired the most agent-agnostic way it supports:
    - **`context-mode`** — context optimizer + FTS5 memory, wired as a Claude Code plugin. It ships its own MCP server, so wendkeep deliberately adds no `.mcp.json` entry (registering both cold-started two servers at once). On non-Claude agents, add the MCP by hand: `npx -y context-mode`.
@@ -235,6 +236,7 @@ The README is the map; the guides provide syntax, options, exit codes, examples,
 | **Notes and knowledge** | BUG/APR/ADR, repairs, renumbering, lessons, and dashboard | [Notes and knowledge](https://github.com/rogersialves/wendkeep/blob/main/docs/en/commands/notes-and-knowledge.md) |
 | **Costs and observability** | safe dry-run, tri-state, aggregation, trends, and historical rebuild | [Costs and observability](https://github.com/rogersialves/wendkeep/blob/main/docs/en/commands/costs-and-observability.md) |
 | **Maintenance and diagnostics** | doctor, frontier/manifest freshness, drift, version, and help | [Maintenance and diagnostics](https://github.com/rogersialves/wendkeep/blob/main/docs/en/commands/maintenance-and-diagnostics.md) |
+| **Local Observer** | `observer serve`, registration, snapshots, outbox, and multi-project index | [Local Observer](https://github.com/rogersialves/wendkeep/blob/main/docs/en/commands/observer.md) |
 
 Operations that deserve step-by-step guidance: [verify and exits 0/1/2](https://github.com/rogersialves/wendkeep/blob/main/docs/en/commands/verify.md),
 [legacy-memory migration](https://github.com/rogersialves/wendkeep/blob/main/docs/en/commands/memory-migration.md), and
@@ -357,7 +359,9 @@ Codex uses `session_id`/`turn_id` plus transcript order, with no artificial caus
 
 ### Injection and budgets
 
-`brain-inject` delivers the same revision/hash on `startup`, `/clear`, and `/compact` `SessionStart` events, always placing CORE and SHARED before change context. The full envelope is capped at 24 KiB; CORE reserves up to 4 KiB, SHARED up to 6 KiB, and each line is capped at 320 characters. Under pressure, lessons are removed first, then non-current changes. CORE and SHARED are never prefix-sliced: a missing, invalid, or over-budget layer becomes a visible, repairable `<wk_memory_error>`.
+`CORE.md` is the only manual layer: it accepts up to 40 lines, warns from 35, keeps a 4 KiB ceiling, and caps each line at 320 characters. `SHARED_MEMORY.md` is generated exclusively by the projector and ledger; never edit it to repair state. `brain-inject` delivers the same revision/hash on `startup`, `/clear`, and `/compact` `SessionStart` events, always placing CORE and SHARED before change context. The full envelope is capped at 24 KiB; SHARED reserves up to 6 KiB. Under pressure, lessons are removed first, then non-current changes. CORE and SHARED are never prefix-sliced: a missing, invalid, or over-budget layer becomes a visible, repairable `<wk_memory_error>`.
+
+`memory status --gate` and `validate-memory --vault` also check semantic coverage: they report a code, counts, and active/projected/missing keys. An empty v2 bundle is neutral; a missing projectable event, placeholders as the only content, or an unresolved decision link becomes an explicit degraded/blocking diagnosis without printing memory values.
 
 `DIGEST.md` is no longer the operational handoff: it remains the `/brain-recall` bridge and legacy-vault fallback. A vault without SHARED receives CORE+DIGEST with a deprecation warning; migrate during the compatibility window:
 

package/docs/en/commands/changes-and-verification.md

@@ -77,6 +77,10 @@ tool runs, it compares the session, project, Git root, remote, branch, and workt
 recorded in `SESSION_REGISTRY.json`. Missing, ambiguous, concurrent, or cross-project targets are
 blocked before the tool.
 
+The [local Observer](observer.md) is a read-only observability projection: the vault and change
+remain local authorities. Observer queries do not complete, archive, repair, or promote state in a
+vault.
+
 Codex blocks with `permissionDecision: "deny"`; `ask` is not a valid `PreToolUse` decision.
 `commit`, `push`, `pull`, `merge`, `publish`, and destructive operations remain separate capabilities,
 including when one command contains multiple actions. Switching projects requires a new explicit

package/docs/en/commands/costs-and-observability.md

@@ -19,7 +19,8 @@ projects whose registries are mixed.
 
 ## Prerequisites
 
-A consistent registry, complete price table, and transcript access for rebuilt sessions.
+A consistent registry, a price table for models with published rates, and transcript access for
+rebuilt sessions. A research preview without a final rate must remain explicitly unestimated.
 
 ## Syntax
 
@@ -64,9 +65,17 @@ returns `complete`, `none`, or `degraded`, plus a frontier, manifest, and saniti
 Run and review the dry-run before repeating the same command with `--apply`; a semantically
 identical second apply preserves the note, checkpoint, report, and mtime.
 
+## Models without a final rate
+
+`doctor` separates a model that is truly missing from the table from a known
+`research-preview` model. The former remains actionable and asks for an update to
+`hooks/pricing.json`; the latter is reported as **final rate not published** and **cost not
+estimated**. Do not copy another model's price into the gap.
+
 ## Common errors and diagnosis
 
-- Model without a price: update the table before accepting totals.
+- Unknown model without a price: update the table before accepting totals.
+- Research preview without a final rate: keep the cost unestimated; do not invent a rate.
 - Wrong-provider costs: validate the session identity chain.
 - Missing transcript: do not estimate silently; keep the gap visible.
 - Duplicated parent/subagent/fork totals: verify registry relationships and deduplication.

package/docs/en/commands/memory.md

@@ -7,6 +7,10 @@
 Inspect and curate CORE, SHARED, ledger, outbox, attempts, and candidates without confusing
 canonical authorship with generated operational state.
 
+`CORE.md` is the only manual, canonical layer: it accepts up to 40 lines, warns from 35,
+keeps a 4 KiB ceiling, and caps each line at 320 characters. `SHARED_MEMORY.md` is generated
+from the ledger and must not be hand-edited.
+
 ## When to use
 
 Use in CI, before verify/archive, after doctor warnings, or when deciding candidates.
@@ -115,7 +119,12 @@ npx wendkeep validate-memory --vault <v2-vault>
   different, incomplete, or ambiguous identity keeps the candidate queued for curation. `memory
   repair` compares the old and current replay and migrates checkpoint+mirror only with exact
   identity, backup, audit, and CAS; it does not reorder, rewrite, or append a ledger event.
-- `validate-memory <CORE.md>` checks the 25-line cap, required sections, and secrets.
+- `validate-memory <CORE.md>` checks the hard 40-line cap, warns from 35, enforces 4 KiB and
+  320 characters per line, and checks required sections and secrets/PII.
+- `validate-memory --vault` also compares semantic ledger coverage with SHARED and prints a code,
+  counts, and active/projected/missing keys. An empty v2 bundle is neutral; a missing projectable
+  event, exclusive placeholders, or a dead decision link produces a degraded/blocking diagnosis
+  without exposing values.
 - `validate-memory --vault` requires a complete v2 bundle and is not the legacy-vault gate.
 - For `recover-attempt`, exit `0` means a valid dry run/apply, including `unchanged`; exit `1`
   means a precondition, authority, CAS, topology, or lock check failed; exit `2` means a missing

package/docs/en/commands/observer.md

@@ -0,0 +1,104 @@
+# Local Observer
+
+**English** · [Português](../../pt-BR/commands/observer.md)
+
+## Purpose
+
+The Observer consolidates observability for multiple WendKeep projects in a local service without
+copying or taking ownership of their vaults.
+
+## When to use
+
+Use it to query summarized changes, sessions, tasks, and health across projects through one local
+projection while each vault remains authoritative.
+
+## When not to use
+
+Do not use the Observer to edit, complete, or archive changes, curate memory, store transcripts,
+or replace local hooks. Do not expose it to the network in this version.
+
+## Prerequisites
+
+Initialize projects with WendKeep, explicitly register each project, and set a local token before
+starting the HTTP server.
+
+## Syntax
+
+```bash
+npx wendkeep observer status --data-dir <directory> --json
+npx wendkeep observer register --project <project> --vault <vault> --data-dir <directory>
+npx wendkeep observer publish --project <project> --vault <vault> --data-dir <directory>
+npx wendkeep observer serve --host 127.0.0.1 --port 8787 --data-dir <directory>
+```
+
+## Options and exit codes
+
+- `--data-dir` selects the local event and index directory; the default is
+  `WENDKEEP_OBSERVER_DATA_DIR` or `~/.wendkeep-observer`.
+- `--project` and `--vault` identify a project only for `register` and `publish`.
+- `--host` accepts only `127.0.0.1`, `localhost`, or `::1`; other hosts are rejected before
+  listening.
+- `--token` or `WENDKEEP_OBSERVER_TOKEN` protects `/v1`; `GET /healthz` exposes no project data.
+- Exit `0` means success; exit `1` means configuration or operation failure; the publisher hook
+  also returns `0` when the Observer is unavailable.
+
+## Examples
+
+```powershell
+$env:WENDKEEP_OBSERVER_TOKEN = '<local-token>'
+npx wendkeep observer register --project C:\GitHub\WendKeep --vault C:\GitHub\WendKeep\.WendKeep-vault --data-dir C:\WendKeepObserver
+npx wendkeep observer serve --host 127.0.0.1 --port 8787 --data-dir C:\WendKeepObserver
+$env:WENDKEEP_OBSERVER_URL = 'http://127.0.0.1:8787'
+```
+
+For local Docker:
+
+```powershell
+$env:WENDKEEP_OBSERVER_TOKEN = '<local-token>'
+docker compose -f docker/wendkeep-observer/compose.yaml up -d --build
+```
+
+## Expected result
+
+`register` stores only `project_id`, name, version, and registration time. `publish` reads the
+local vault, produces a sanitized snapshot, and sends an idempotent event. The container stores
+only `EVENTS.jsonl` and `INDEX.json` in the `observer-data` volume; it does not mount `C:\GitHub`
+or any `.WendKeep-vault`.
+
+`init` projects `observer-publish` into `SessionStart` and `Stop` after the primary hooks. Without
+`WENDKEEP_OBSERVER_URL`, the hook is a no-op. When the server is stopped, it writes to
+`.brain/observer-outbox/` and does not block the session; a later run retries pending events.
+
+## Common errors and diagnosis
+
+- `project_not_registered`: run `observer register` before publishing.
+- `unauthorized`: check `Authorization: Bearer <token>` and `WENDKEEP_OBSERVER_TOKEN`.
+- `host loopback`: replace `0.0.0.0` or a LAN address with `127.0.0.1`.
+- Pending outbox: the service was unavailable; preserve `.brain/observer-outbox/` and rerun the
+  publisher. Do not delete events manually.
+- The Observer does not read raw content, paths, transcripts, or memory; such rejections are
+  expected and should be investigated at the snapshot source.
+
+## Next steps
+
+Read the `local-observer` change for the `OBS-1` through `OBS-8` contract. Do not remove the Docker
+volume with `docker compose down -v` during normal operation because it deletes the local
+projection.
+
+## Data authority
+
+Each project vault remains authoritative for sessions, changes, tasks, memory, and evidence. The
+Observer is a read-only, rebuildable projection; its queries do not complete, archive, repair, or
+promote state in a vault.
+
+## Minimal API
+
+- `GET /healthz` — availability without project data.
+- `GET /v1/projects` — projects with an accepted snapshot.
+- `GET /v1/projects/:project_id` — the latest project snapshot.
+- `GET /v1/projects/:project_id/changes` — change summary from the snapshot.
+- `PUT /v1/projects/:project_id` — authenticated explicit registration.
+- `POST /v1/projects/:project_id/snapshot` — authenticated idempotent ingestion.
+
+The `/v1` routes reject oversized bodies and never accept vault paths, transcripts, secrets, or raw
+memory content.

package/docs/pt-BR/commands/changes-and-verification.md

@@ -77,6 +77,10 @@ uma ferramenta de escrita suportada, ele compara sessão, projeto, raiz Git, rem
 worktree com a lease registrada no `SESSION_REGISTRY.json`. Um alvo ausente, ambíguo, concorrente ou
 fora do projeto é bloqueado antes da ferramenta.
 
+O [Observer local](observer.md) é uma projeção read-only da observabilidade: o vault e a change
+continuam autoridades locais. Consultas do Observer não concluem, arquivam, reparam ou promovem
+estado no vault.
+
 No Codex o bloqueio usa `permissionDecision: "deny"`; `ask` não é uma decisão válida de
 `PreToolUse`. `commit`, `push`, `pull`, `merge`, `publish` e operações destrutivas continuam
 capacidades separadas, inclusive quando um comando contém mais de uma ação. A troca de projeto

package/docs/pt-BR/commands/costs-and-observability.md

@@ -19,7 +19,9 @@ projetos com registries misturados.
 
 ## Pré-requisitos
 
-Registry consistente, tabela de preços completa e acesso aos transcripts das sessões reconstruídas.
+Registry consistente, tabela de preços para os modelos com tarifa publicada e acesso aos transcripts
+das sessões reconstruídas. Um research preview sem tarifa final deve permanecer explicitamente
+como custo não estimado.
 
 ## Sintaxe
 
@@ -64,9 +66,17 @@ tri-state devolve `complete`, `none` ou `degraded`, mais frontier, manifest e di
 sanitizados. Rode e revise o dry-run antes de repetir o mesmo comando com `--apply`; uma segunda
 aplicação semanticamente idêntica preserva nota, checkpoint, relatório e mtime.
 
+## Modelos sem tarifa final
+
+O `doctor` separa um modelo realmente ausente da tabela de um modelo conhecido em
+`research-preview`. O primeiro continua acionável e pede atualização de
+`hooks/pricing.json`; o segundo aparece como **tarifa final não publicada** e **custo não
+estimado**. Não copie o preço de outro modelo para preencher essa lacuna.
+
 ## Erros comuns e diagnóstico
 
-- Modelo sem preço: atualize a tabela antes de aceitar o total.
+- Modelo desconhecido sem preço: atualize a tabela antes de aceitar o total.
+- Research preview sem tarifa final: mantenha o custo não estimado; não invente uma tarifa.
 - Custos de provider errado: valide a cadeia de identidade da sessão.
 - Transcript ausente: não estime silenciosamente; mantenha a lacuna visível.
 - Total duplicado por subagent/fork: confirme relação pai/subagent e deduplicação do registry.

package/docs/pt-BR/commands/memory.md

@@ -7,6 +7,10 @@
 Inspecionar e curar CORE, SHARED, ledger, outbox, attempts e candidates sem confundir autoria
 canônica com estado operacional gerado.
 
+`CORE.md` é a única camada manual e canônica: aceita até 40 linhas, alerta a partir de 35,
+mantém o teto de 4 KiB e limita cada linha a 320 caracteres. `SHARED_MEMORY.md` é uma projeção
+gerada pelo ledger e não deve ser editado à mão.
+
 ## Quando usar
 
 Use no CI, antes de verify/archive, diante de avisos do doctor ou para decidir candidates.
@@ -113,7 +117,12 @@ npx wendkeep validate-memory --vault <cofre-v2>
   divergente, incompleta ou ambígua mantém o candidate para curadoria. `memory repair` compara o
   replay anterior e o atual e só migra checkpoint+espelho com identidade exata, backup, audit e
   CAS; ele não reordena, reescreve nem acrescenta evento ao ledger.
-- `validate-memory <CORE.md>` valida cap de 25 linhas, seções e segredos.
+- `validate-memory <CORE.md>` valida cap rígido de 40 linhas, alerta em 35, 4 KiB, 320 caracteres
+  por linha, seções e segredos/PII.
+- `validate-memory --vault` também compara a cobertura semântica do ledger com SHARED e imprime
+  código, contagens e chaves ativas/projetadas/ausentes. Bundle v2 vazio é neutro; evento
+  projetável ausente, placeholders exclusivos ou link de decisão morto geram diagnóstico
+  degradado/bloqueante sem expor valores.
 - `validate-memory --vault` exige bundle v2 completo; não é o gate correto para vault legado.
 - Para `recover-attempt`, exit `0` indica dry-run/apply válido, inclusive `unchanged`; exit `1`
   indica falha de pré-condição, autoridade, CAS, topologia ou lock; exit `2` indica

package/docs/pt-BR/commands/observer.md

@@ -0,0 +1,105 @@
+# Observer local
+
+**PT-BR** · [English](../../en/commands/observer.md)
+
+## Objetivo
+
+O Observer consolida a observabilidade de vários projetos WendKeep em um serviço local, sem
+copiar ou assumir a propriedade dos vaults.
+
+## Quando usar
+
+Use para consultar changes, sessões, tarefas resumidas e saúde de vários projetos em uma única
+projeção local, mantendo cada vault como fonte oficial.
+
+## Quando não usar
+
+Não use o Observer para editar, concluir ou arquivar changes, curar memória, armazenar transcripts
+ou substituir os hooks locais. Não o exponha na rede nesta versão.
+
+## Pré-requisitos
+
+Tenha os projetos inicializados com WendKeep, registre explicitamente cada projeto e defina um
+token local antes de iniciar o servidor HTTP.
+
+## Sintaxe
+
+```bash
+npx wendkeep observer status --data-dir <diretório> --json
+npx wendkeep observer register --project <projeto> --vault <vault> --data-dir <diretório>
+npx wendkeep observer publish --project <projeto> --vault <vault> --data-dir <diretório>
+npx wendkeep observer serve --host 127.0.0.1 --port 8787 --data-dir <diretório>
+```
+
+## Opções e códigos de saída
+
+- `--data-dir` escolhe o diretório local de eventos e índice; o padrão é
+  `WENDKEEP_OBSERVER_DATA_DIR` ou `~/.wendkeep-observer`.
+- `--project` e `--vault` identificam o projeto somente nos comandos `register` e `publish`.
+- `--host` aceita somente `127.0.0.1`, `localhost` ou `::1`; outros hosts são recusados antes do
+  listen.
+- `--token` ou `WENDKEEP_OBSERVER_TOKEN` protege as rotas `/v1`; `GET /healthz` permanece sem
+  dados de projeto.
+- Exit `0` indica sucesso; exit `1` indica falha de configuração ou operação; o hook publisher
+  também retorna `0` quando o Observer está indisponível.
+
+## Exemplos
+
+```powershell
+$env:WENDKEEP_OBSERVER_TOKEN = '<token-local>'
+npx wendkeep observer register --project C:\GitHub\WendKeep --vault C:\GitHub\WendKeep\.WendKeep-vault --data-dir C:\WendKeepObserver
+npx wendkeep observer serve --host 127.0.0.1 --port 8787 --data-dir C:\WendKeepObserver
+$env:WENDKEEP_OBSERVER_URL = 'http://127.0.0.1:8787'
+```
+
+Para Docker local:
+
+```powershell
+$env:WENDKEEP_OBSERVER_TOKEN = '<token-local>'
+docker compose -f docker/wendkeep-observer/compose.yaml up -d --build
+```
+
+## Resultado esperado
+
+`register` grava apenas `project_id`, nome, versão e data de registro. `publish` lê o vault local,
+produz um snapshot sanitizado e envia um evento idempotente. O container mantém somente
+`EVENTS.jsonl` e `INDEX.json` no volume `observer-data`; não monta `C:\GitHub` nem qualquer
+`.WendKeep-vault`.
+
+O `init` projeta `observer-publish` para `SessionStart` e `Stop` depois dos hooks principais. Sem
+`WENDKEEP_OBSERVER_URL`, o hook é no-op. Com o servidor parado, ele grava em
+`.brain/observer-outbox/` e não bloqueia a sessão; uma execução posterior tenta reenviar eventos
+pendentes.
+
+## Erros comuns e diagnóstico
+
+- `project_not_registered`: rode `observer register` antes de publicar.
+- `unauthorized`: confira `Authorization: Bearer <token>` e `WENDKEEP_OBSERVER_TOKEN`.
+- `host loopback`: troque `0.0.0.0` ou endereço LAN por `127.0.0.1`.
+- Outbox pendente: o serviço estava indisponível; preserve `.brain/observer-outbox/` e repita o
+  publisher. Não apague eventos manualmente.
+- O Observer não lê conteúdo bruto, caminhos, transcripts ou memória; rejeições desse tipo são
+  esperadas e devem ser investigadas na origem do snapshot.
+
+## Próximos passos
+
+Leia a change `local-observer` para o contrato `OBS-1` a `OBS-8`. O volume Docker não deve ser
+removido com `docker compose down -v` durante a operação normal, pois isso apaga a projeção local.
+
+## Autoridade dos dados
+
+O vault de cada projeto continua sendo a fonte oficial de sessões, changes, tarefas, memória e
+evidências. O Observer é uma projeção read-only reconstruível; suas consultas não concluem,
+arquivam, reparam ou promovem estado no vault.
+
+## API mínima
+
+- `GET /healthz` — disponibilidade sem dados de projeto.
+- `GET /v1/projects` — projetos com snapshot aceito.
+- `GET /v1/projects/:project_id` — último snapshot do projeto.
+- `GET /v1/projects/:project_id/changes` — resumo das changes do snapshot.
+- `PUT /v1/projects/:project_id` — registro explícito autenticado.
+- `POST /v1/projects/:project_id/snapshot` — ingestão autenticada e idempotente.
+
+As rotas `/v1` rejeitam corpo acima do limite e nunca aceitam caminho de vault, transcript, segredo
+ou conteúdo bruto de memória.

package/hooks/brain-core.mjs

@@ -4,6 +4,7 @@ import { existsSync, readdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { basename, join } from 'node:path';
 import { ensureDir, stripYamlQuotes, toVaultRelative } from './obsidian-common.mjs';
 import { getLocale } from './locale.mjs';
+import { sanitizeMemoryText } from './memory-schema.mjs';
 
 export function brainDir(vaultBase) {
   return join(vaultBase, '.brain');
@@ -104,6 +105,41 @@ function adrNumber(path) {
   return m ? Number(m[1]) : -1;
 }
 
+function decisionTitle(content, path) {
+  const frontmatter = parseFrontmatter(content);
+  const heading = content.match(/^#\s+(.+?)\s*$/m)?.[1] || '';
+  const raw = frontmatter.title || frontmatter.name || heading;
+  if (!raw) return '';
+  const title = sanitizeMemoryText(String(raw)
+    .replace(/^ADR-\d+\s*(?:[-:—]\s*)?/i, '')
+    .replace(/\s+/g, ' ')
+    .trim());
+  return title.slice(0, 180).trim();
+}
+
+function decisionNotes(vaultBase) {
+  const byPath = new Map();
+  const byBasename = new Map();
+  const decisionsDir = join(vaultBase, getLocale(vaultBase).folders.decisions);
+  for (const filePath of walkMd(decisionsDir)) {
+    let content;
+    try { content = readFileSync(filePath, 'utf8'); } catch { continue; }
+    const rel = toVaultRelative(vaultBase, filePath).replace(/\.md$/i, '');
+    const note = { path: rel, title: decisionTitle(content, rel) };
+    byPath.set(rel, note);
+    const key = basename(rel);
+    if (!byBasename.has(key)) byBasename.set(key, note);
+  }
+  return { byPath, byBasename };
+}
+
+function resolveDecisionTarget(target, notes) {
+  const normalized = String(target || '').replace(/\.md$/i, '').trim();
+  if (!normalized || normalized.includes('...') || normalized.includes('…')) return null;
+  const note = notes.byPath.get(normalized) || notes.byBasename.get(basename(normalized));
+  return note?.title ? note : null;
+}
+
 // Destila index.jsonl em .brain/DIGEST.md (camada quente, determinístico, 0 token LLM).
 // Cap por construção: 1 header + 13 itens (5/4/2/2) + 1 pointer = máx 15 linhas.
 export function buildBrainDigest(vaultBase, rows = null) {
@@ -139,13 +175,21 @@ export function buildBrainDigest(vaultBase, rows = null) {
   };
   const pickLive = (kind, max) => pick(kind, max * 4).filter(resolves).slice(0, max);
 
-  const decisions = pickLive('decisions', DIGEST_CAPS.decisions).sort((a, b) => adrNumber(b) - adrNumber(a));
+  const notes = decisionNotes(vaultBase);
+  const decisions = [];
+  for (const target of pick('decisions', DIGEST_CAPS.decisions * 4)) {
+    const resolved = resolveDecisionTarget(target, notes);
+    if (!resolved || decisions.some((item) => item.path === resolved.path)) continue;
+    decisions.push(resolved);
+    if (decisions.length >= DIGEST_CAPS.decisions) break;
+  }
+  decisions.sort((a, b) => adrNumber(b.path) - adrNumber(a.path));
   const sessions = byDateDesc.slice(0, DIGEST_CAPS.sessions);
   const bugs = pickLive('bugs', DIGEST_CAPS.bugs);
   const learnings = pickLive('learnings', DIGEST_CAPS.learnings);
 
   const lines = ['<!-- AUTO-GERADO por brain-core.mjs (0 token LLM). NÃO editar. Rebuild: node .agent/hooks/brain-reindex.mjs -->'];
-  for (const d of decisions) lines.push(`- Decisão: [[${d}]]`);
+  for (const d of decisions) lines.push(`- Decisão: [[${d.path}]] — ${d.title}`);
   for (const s of sessions) lines.push(`- Sessão ${s.date} (${s.provider || '?'}): ${s.summary || s.file} → [[${String(s.file || '').replace(/\.md$/, '')}]]`);
   for (const b of bugs) lines.push(`- Bug: [[${b}]]`);
   for (const l of learnings) lines.push(`- Aprendizado: [[${l}]]`);

package/hooks/brain-inject.mjs

@@ -19,7 +19,7 @@ import {
   resolveHookOperatingProfile,
 } from './operating-profile-runtime.mjs';
 import { assertVaultPathSafe } from './vault-path-safety.mjs';
-import { validateCore } from '../src/validate-core.mjs';
+import { CORE_LIMITS, validateCore } from '../src/validate-core.mjs';
 
 // The process ROUTER — the enforcement layer. The wk-* skills are passive files; without a
 // standing instruction the model plans in chat, leaves the change scaffold raw and forces the
@@ -52,8 +52,8 @@ function processRouter(localeId) {
 
 const INJECTION_LIMITS = Object.freeze({
   totalBytes: 24 * 1024,
-  lineChars: 320,
-  coreBytes: 4 * 1024,
+  lineChars: CORE_LIMITS.lineChars,
+  coreBytes: CORE_LIMITS.bytes,
   sharedBytes: 6 * 1024,
   attentionBytes: 1024,
   recallBytes: 512,

package/hooks/harness-doctor.mjs

@@ -212,9 +212,11 @@ export function checkStackedFrontmatter(vaultBase) {
 }
 
 // Um modelo fora de `pricing.json` faz `priceForModel` devolver null e a parcela dele do custo
-// virar zero — sem erro, sem aviso. Modelo novo (claude-opus-5, claude-mythos-5) cai nisso por
-// default. A checagem é sobre o vault, não sobre o caminho de cálculo: o cálculo roda em hook a
-// cada turno, onde avisar viraria ruído e lançar derrubaria a captura da sessão.
+// virar zero — sem erro, sem aviso. Modelos conhecidos sem tarifa final (por exemplo, um
+// research preview) ficam na tabela com status explícito e são reportados separadamente: isso
+// evita tanto o silêncio quanto a sugestão de inventar um preço. A checagem é sobre o vault, não
+// sobre o caminho de cálculo: o cálculo roda em hook a cada turno, onde avisar viraria ruído e
+// lançar derrubaria a captura da sessão.
 //
 // Cada modelo citado na nota é consultado direto em `priceForModel` — NÃO se infere pelo
 // sintoma "custo zerado". Numa sessão multi-modelo (`modelo: "claude-opus-4.8 + claude-opus-5"`)
@@ -222,6 +224,7 @@ export function checkStackedFrontmatter(vaultBase) {
 // motivou esta change, a nota fecha com $415 e a fatia do Opus 5 é a única zerada.
 export function checkUnpricedModels(vaultBase) {
   const counts = new Map();
+  const researchPreview = new Map();
 
   const modelsOf = (frontmatter) => {
     // `modelos:` é a lista canônica; `modelo:` é o rótulo agregado (junta com " + ").
@@ -247,23 +250,34 @@ export function checkUnpricedModels(vaultBase) {
       for (const raw of modelsOf(fm[1])) {
         const model = raw.trim().replace(/^["']|["']$/g, '');
         if (!model || model === 'unknown') continue;
-        if (priceForModel(model)) continue;
-        counts.set(model, (counts.get(model) || 0) + 1);
+        const price = priceForModel(model);
+        if (price?.pricingStatus === 'research-preview') {
+          researchPreview.set(model, (researchPreview.get(model) || 0) + 1);
+        } else if (!price) {
+          counts.set(model, (counts.get(model) || 0) + 1);
+        }
       }
     }
   };
 
   walk(join(vaultBase, '02-Sessões'));
-  return { models: [...counts].map(([model, notes]) => ({ model, notes })) };
+  return {
+    models: [...counts].map(([model, notes]) => ({ model, notes })),
+    researchPreview: [...researchPreview].map(([model, notes]) => ({ model, notes })),
+  };
 }
 
 export function renderUnpricedModelLines(unpriced) {
+  const preview = unpriced.researchPreview || [];
   const lines = [`[preços] ${unpriced.models.length} modelo(s) sem preço na tabela`];
   for (const { model, notes } of unpriced.models) {
     lines.push(`  ✗ ${model} (${notes} nota(s) com custo zerado)`);
   }
   if (unpriced.models.length) lines.push('  → adicione o modelo em hooks/pricing.json');
-  else lines.push('  tabela de preços completa ✓');
+  else if (!preview.length) lines.push('  tabela de preços completa ✓');
+  for (const { model, notes } of preview) {
+    lines.push(`  ! ${model} (${notes} nota(s)): research preview sem tarifa final; custo não estimado`);
+  }
   return lines;
 }