wendkeep 0.76.8 → 0.76.9

package/CHANGELOG.md

@@ -4,6 +4,20 @@ 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.76.9] — 2026-08-22
+
+### Fixed
+
+- **Injeção de change causal.** `brain-inject` e `change-context` usam o active context da sessão
+  para marcar `ATUAL`, calcular o hash da sentinela e preservar o mesmo foco em todos os degraus do
+  budget; o backlog continua global sem promover a change irmã pelo pointer legado.
+- **Store vazio fail-closed.** A presença de `active_contexts`, schema ou revision — inclusive
+  `active_contexts: {}` — impede fallback a `CURRENT_CHANGE.md` quando o contexto causal está ausente
+  ou ambíguo; compatibilidade legada permanece somente antes da inicialização contextual.
+- **Criação contextual preservada.** Operações mutáveis como `delivery start` continuam recebendo a
+  identidade causal antes de existir um context record, enquanto hooks read-only exigem o registro
+  existente e nunca publicam foco de sibling.
+
 ## [0.76.8] — 2026-08-22
 
 ### Added

package/README.en.md

@@ -116,6 +116,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`** — twelve compatible entries: `brain-inject` + `session-start` + `observer-publish` on `SessionStart`, `session-ensure` + `evidence-context` + `change-context` on `UserPromptSubmit`, `session-stop` + `observer-publish` + `change-nag` on `Stop`, `subagent-stop` + `observer-publish` 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. For the Observer, `SessionStart` only drains the outbox, `Stop` enqueues the changed session, and `SubagentStop` enqueues only the affected transcript; full scanning is explicit through `observer reconcile`. 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. A raw `git checkout/switch` branch transition is denied before it can strand the session; use `wendkeep context switch <branch> [--create]`, which moves Git and the causal scope together in the same worktree with an audited revision and rollback. If a divergence is already quarantined, `context status --session <id>` inventories sanitized `reserved`/`observed` candidates; `context recover --session <id> --select <reserved|observed> --revision <n> --reason <text>` requires an explicit choice, CAS, and current-checkout proof, failing closed before clearing the conflict if revalidation changes. `doctor` diagnoses orphaned active contexts, removed worktrees, and expired `request-stop` leases without writing; `context repair --key <key> --revision <n> --reason <text> --session <id>` revalidates under lock, closes only the ownerless/removed context or expires only its lease, while preserving the record and all historical memory. The change lifecycle uses `active_contexts`, identified by `repository_id` + `worktree_id` + `work_session_id`; two matching sessions fail with ambiguity instead of selecting silently, `CURRENT_CHANGE.md` is only a derived projection for one unambiguous context, and migration never invents a worktree or session identity. 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**.
+   Once `active_contexts` is initialized, `brain-inject` and `change-context` mark only the causal context's change as current; the backlog remains global, and an empty or ambiguous store never revives `CURRENT_CHANGE.md`.
 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`.
@@ -582,7 +583,7 @@ agent session ──hooks──▶ wendkeep ──▶ Markdown in vault ──
    (Claude/Codex)        (Node)      (02-Sessões/…)        (CORE+SHARED, ledger, backlinks)
 ```
 
-The agent's settings.json points each hook at `npx wendkeep hook …`; **in Claude Code** the change-lifecycle hooks instead run the installed script directly (`node` on `${CLAUDE_PROJECT_DIR}/node_modules/wendkeep/hooks/<name>.mjs`) when the package is present locally, skipping an npx resolve on every event. `.codex/hooks.json` mirrors the same groups with PascalCase event keys, but always uses the `npx` form (`${CLAUDE_PROJECT_DIR}` does not exist in Codex) and spells its timeout `timeoutSec` — a plain `timeout` is neither a field nor an error there, it silently falls through to a 600s default, so `init` migrates that legacy key in place. On `Stop`, wendkeep parses the session transcript, appends the turn, updates token/cost data, emits derived notes, and publishes the sanitized handoff to the memory outbox. On `SessionStart` — startup, `/clear`, and `/compact` — `brain-inject` injects CORE + SHARED, every open change with its pending tasks, the global current-change marker, project lessons, and a `<wk_process>` router. Claude, Codex, or another agent can therefore resume work started elsewhere without hiding the rest of the backlog.
+The agent's settings.json points each hook at `npx wendkeep hook …`; **in Claude Code** the change-lifecycle hooks instead run the installed script directly (`node` on `${CLAUDE_PROJECT_DIR}/node_modules/wendkeep/hooks/<name>.mjs`) when the package is present locally, skipping an npx resolve on every event. `.codex/hooks.json` mirrors the same groups with PascalCase event keys, but always uses the `npx` form (`${CLAUDE_PROJECT_DIR}` does not exist in Codex) and spells its timeout `timeoutSec` — a plain `timeout` is neither a field nor an error there, it silently falls through to a 600s default, so `init` migrates that legacy key in place. On `Stop`, wendkeep parses the session transcript, appends the turn, updates token/cost data, emits derived notes, and publishes the sanitized handoff to the memory outbox. On `SessionStart` — startup, `/clear`, and `/compact` — `brain-inject` injects CORE + SHARED, every open change with its pending tasks, the causal current-change marker, project lessons, and a `<wk_process>` router. The inventory remains global, but `CURRENT` and the sentinel hash come from the session's active context; `active_contexts: {}` fails closed instead of reviving `CURRENT_CHANGE.md`. Claude, Codex, or another agent can therefore resume work started elsewhere without hiding the rest of the backlog.
 
 The archive **gate** blocks unless: the change scaffold is filled (G0), no task is open (G1), every declared critical sensor is green (with fresh evidence), and a `verdict.json` is present and current. `--force` waives G1 only — G0 is inescapable by design (a placeholder change forced through once minted a fake ADR), and no flag turns a red sensor or a missing verdict green. The agent is instructed never to use it on its own.
 

package/README.md

@@ -116,6 +116,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`** — twelve compatible entries: `brain-inject` + `session-start` + `observer-publish` on `SessionStart`, `session-ensure` + `evidence-context` + `change-context` on `UserPromptSubmit`, `session-stop` + `observer-publish` + `change-nag` on `Stop`, `subagent-stop` + `observer-publish` 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. For the Observer, `SessionStart` only drains the outbox, `Stop` enqueues the changed session, and `SubagentStop` enqueues only the affected transcript; full scanning is explicit through `observer reconcile`. 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. A raw `git checkout/switch` branch transition is denied before it can strand the session; use `wendkeep context switch <branch> [--create]`, which moves Git and the causal scope together in the same worktree with an audited revision and rollback. If a divergence is already quarantined, `context status --session <id>` inventories sanitized `reserved`/`observed` candidates; `context recover --session <id> --select <reserved|observed> --revision <n> --reason <text>` requires an explicit choice, CAS, and current-checkout proof, failing closed before clearing the conflict if revalidation changes. `doctor` diagnoses orphaned active contexts, removed worktrees, and expired `request-stop` leases without writing; `context repair --key <key> --revision <n> --reason <text> --session <id>` revalidates under lock, closes only the ownerless/removed context or expires only its lease, while preserving the record and all historical memory. The change lifecycle uses `active_contexts`, identified by `repository_id` + `worktree_id` + `work_session_id`; two matching sessions fail with ambiguity instead of selecting silently, `CURRENT_CHANGE.md` is only a derived projection for one unambiguous context, and migration never invents a worktree or session identity. 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**.
+   Once `active_contexts` is initialized, `brain-inject` and `change-context` mark only the causal context's change as current; the backlog remains global, and an empty or ambiguous store never revives `CURRENT_CHANGE.md`.
 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`.
@@ -582,7 +583,7 @@ agent session ──hooks──▶ wendkeep ──▶ Markdown in vault ──
    (Claude/Codex)        (Node)      (02-Sessões/…)        (CORE+SHARED, ledger, backlinks)
 ```
 
-The agent's settings.json points each hook at `npx wendkeep hook …`; **in Claude Code** the change-lifecycle hooks instead run the installed script directly (`node` on `${CLAUDE_PROJECT_DIR}/node_modules/wendkeep/hooks/<name>.mjs`) when the package is present locally, skipping an npx resolve on every event. `.codex/hooks.json` mirrors the same groups with PascalCase event keys, but always uses the `npx` form (`${CLAUDE_PROJECT_DIR}` does not exist in Codex) and spells its timeout `timeoutSec` — a plain `timeout` is neither a field nor an error there, it silently falls through to a 600s default, so `init` migrates that legacy key in place. On `Stop`, wendkeep parses the session transcript, appends the turn, updates token/cost data, emits derived notes, and publishes the sanitized handoff to the memory outbox. On `SessionStart` — startup, `/clear`, and `/compact` — `brain-inject` injects CORE + SHARED, every open change with its pending tasks, the global current-change marker, project lessons, and a `<wk_process>` router. Claude, Codex, or another agent can therefore resume work started elsewhere without hiding the rest of the backlog.
+The agent's settings.json points each hook at `npx wendkeep hook …`; **in Claude Code** the change-lifecycle hooks instead run the installed script directly (`node` on `${CLAUDE_PROJECT_DIR}/node_modules/wendkeep/hooks/<name>.mjs`) when the package is present locally, skipping an npx resolve on every event. `.codex/hooks.json` mirrors the same groups with PascalCase event keys, but always uses the `npx` form (`${CLAUDE_PROJECT_DIR}` does not exist in Codex) and spells its timeout `timeoutSec` — a plain `timeout` is neither a field nor an error there, it silently falls through to a 600s default, so `init` migrates that legacy key in place. On `Stop`, wendkeep parses the session transcript, appends the turn, updates token/cost data, emits derived notes, and publishes the sanitized handoff to the memory outbox. On `SessionStart` — startup, `/clear`, and `/compact` — `brain-inject` injects CORE + SHARED, every open change with its pending tasks, the causal current-change marker, project lessons, and a `<wk_process>` router. The inventory remains global, but `CURRENT` and the sentinel hash come from the session's active context; `active_contexts: {}` fails closed instead of reviving `CURRENT_CHANGE.md`. Claude, Codex, or another agent can therefore resume work started elsewhere without hiding the rest of the backlog.
 
 The archive **gate** blocks unless: the change scaffold is filled (G0), no task is open (G1), every declared critical sensor is green (with fresh evidence), and a `verdict.json` is present and current. `--force` waives G1 only — G0 is inescapable by design (a placeholder change forced through once minted a fake ADR), and no flag turns a red sensor or a missing verdict green. The agent is instructed never to use it on its own.
 

package/docs/en/commands/context.md

@@ -117,6 +117,14 @@ unambiguous active context. With zero or multiple contexts it stays empty. Migra
 and never invents a worktree or session identity. The legacy pointer becomes a context only
 when one active session, a complete scope, and worktree metadata prove one identity.
 
+The `brain-inject` (`SessionStart`) and `change-context` (`UserPromptSubmit`) hooks resolve the same
+causal identity before marking a change as `CURRENT` or computing the sentinel hash. The backlog
+remains global and lists every other change as `OPEN`, but a divergent `CURRENT_CHANGE.md` never
+turns a sibling change into the session focus. The presence of `active_contexts`, its schema, or its
+revision — including `active_contexts: {}` — disables legacy fallback: a missing or ambiguous
+context fails closed without reviving the pointer. Fallback exists only before contextual-store
+initialization.
+
 ## Common errors and diagnosis
 
 - `WENDKEEP_CONTEXT_AMBIGUOUS`: pass `--session <id>`; no candidate is selected silently.

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

@@ -114,6 +114,13 @@ contexto ativo inequívoco. Com zero ou múltiplos contextos, fica vazio. A migr
 não inventa uma identidade de worktree ou sessão. O ponteiro legado só vira contexto quando uma sessão
 ativa, scope completa e metadados da worktree provam uma única identidade.
 
+Os hooks `brain-inject` (`SessionStart`) e `change-context` (`UserPromptSubmit`) resolvem a mesma
+identidade causal antes de marcar uma change como `ATUAL` ou calcular o hash da sentinela. O backlog
+continua global e lista as demais changes como `ABERTA`, mas um `CURRENT_CHANGE.md` divergente nunca
+transforma a change irmã em foco da sessão. A presença de `active_contexts`, schema ou revision —
+inclusive `active_contexts: {}` — desativa o fallback legado: contexto ausente ou ambíguo falha
+fechado sem reativar o ponteiro. O fallback só existe antes da inicialização do store contextual.
+
 ## Erros comuns e diagnóstico
 
 - `WENDKEEP_CONTEXT_AMBIGUOUS`: informe `--session <id>`; nenhuma candidata é escolhida em silêncio.

package/hooks/active-context-handoff-evidence.mjs

@@ -1,7 +1,12 @@
 import { readSessionRegistry } from './obsidian-common.mjs';
-import { resolveActiveContext } from './active-context-store.mjs';
+import {
+  activeContextRegistryInitialized,
+  resolveActiveContext,
+} from './active-context-store.mjs';
 import { resolveRuntimeActiveContext } from '../src/active-context-runtime.mjs';
 
+export { activeContextRegistryInitialized } from './active-context-store.mjs';
+
 const IDENTITY_FIELDS = Object.freeze([
   ['work_session_id', 'workSessionId'],
   ['repository_id', 'repositoryId'],
@@ -26,12 +31,6 @@ function contextsOf(registry) {
     ? registry.active_contexts : {};
 }
 
-export function activeContextRegistryInitialized(registry = {}) {
-  return Object.hasOwn(registry, 'active_contexts')
-    || Object.hasOwn(registry, 'active_contexts_schema')
-    || Object.hasOwn(registry, 'active_contexts_revision');
-}
-
 function assertAuthority(identity, context) {
   if (!identity || !context || context.state !== 'active') {
     throw contextError(

package/hooks/active-context-store.mjs

@@ -11,6 +11,12 @@ const ID_PATTERN = /^[A-Za-z0-9._-]{1,160}$/;
 const SLUG_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]{0,159}$/;
 const DELIVERY_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]{1,100}$/;
 
+export function activeContextRegistryInitialized(registry = {}) {
+  return Object.hasOwn(registry, 'active_contexts')
+    || Object.hasOwn(registry, 'active_contexts_schema')
+    || Object.hasOwn(registry, 'active_contexts_revision');
+}
+
 function contextError(code, message) {
   const error = new Error(message);
   error.code = code;
@@ -254,7 +260,7 @@ export function migrateLegacyActiveContext(vaultBase, {
   const slug = legacyPointer(vaultBase);
   if (!slug) return { migrated: false, reason: 'no-pointer' };
   const registry = readSessionRegistry(vaultBase);
-  if (Object.keys(contextsOf(registry)).length) return { migrated: false, reason: 'already-initialized' };
+  if (activeContextRegistryInitialized(registry)) return { migrated: false, reason: 'already-initialized' };
   if (typeof identityForSession !== 'function') return { migrated: false, reason: 'identity-unavailable' };
 
   const candidates = [];

package/hooks/brain-inject.mjs

@@ -7,7 +7,12 @@ import { join } from 'node:path';
 import { pathToFileURL } from 'node:url';
 import { readHookInput, writeHookOutput } from './obsidian-common.mjs';
 import { brainDir } from './brain-core.mjs';
-import { buildActiveChangeInjection, changeCtxState, writeSentinel } from './change-core.mjs';
+import {
+  activeChange,
+  buildActiveChangeInjection,
+  changeCtxState,
+  writeSentinel,
+} from './change-core.mjs';
 import { buildLessonsInjection } from './lessons-core.mjs';
 import { getLocale } from './locale.mjs';
 import { resolveSessionEntry } from './session-identity.mjs';
@@ -20,6 +25,7 @@ import {
 } from './operating-profile-runtime.mjs';
 import { assertVaultPathSafe } from './vault-path-safety.mjs';
 import { CORE_LIMITS, validateCore } from '../src/validate-core.mjs';
+import { resolveCommandActiveContext } from '../src/active-context-runtime.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
@@ -220,7 +226,9 @@ function budgetNotice(priority, layer, message) {
   return `<wk_budget_notice priority="${priority}" layer="${layer}">${message}</wk_budget_notice>`;
 }
 
-export function buildInjection(vaultBase, input = {}, { profile = 'GOVERN', bindingError = null } = {}) {
+export function buildInjection(vaultBase, input = {}, {
+  profile = 'GOVERN', bindingError = null, context = null,
+} = {}) {
   const brain = detectMemoryMode(vaultBase).mode === 'v2'
     ? buildV2Memory(vaultBase)
     : buildLegacyMemory(vaultBase);
@@ -236,10 +244,14 @@ export function buildInjection(vaultBase, input = {}, { profile = 'GOVERN', bind
   // visible below, but the standing change router would contradict that contract.
   const router = policy.requiresChange ? processRouter(getLocale(vaultBase).id) : '';
   const { identity, entry } = resolveSessionEntry(vaultBase, input);
-  const focus = identity.state === 'resolved' && entry?.change_slug
-    ? `<session_change>${boundAncillaryText(`Change vinculada a esta sessão: ${entry.change_slug}. Este vínculo prevalece para writes automáticos; todas as pendências continuam visíveis acima.`, '<session_change></session_change>'.length)}</session_change>`
+  const contextualChange = context ? activeChange(vaultBase, { context }) : '';
+  const sessionChange = contextualChange || (!context && identity.state === 'resolved' ? entry?.change_slug : '');
+  const focus = sessionChange
+    ? `<session_change>${boundAncillaryText(`Change vinculada a esta sessão: ${sessionChange}. Este vínculo prevalece para writes automáticos; todas as pendências continuam visíveis acima.`, '<session_change></session_change>'.length)}</session_change>`
     : '';
-  const allChanges = buildActiveChangeInjection(vaultBase, { maxLineChars: INJECTION_LIMITS.lineChars });
+  const allChanges = buildActiveChangeInjection(vaultBase, {
+    context, maxLineChars: INJECTION_LIMITS.lineChars,
+  });
 
   // Global priority is deterministic: memory/router/focus, then changes, then lessons.
   let output = joinInjection([brain, profileNotice, router, focus, allChanges, lessons]);
@@ -253,6 +265,7 @@ export function buildInjection(vaultBase, input = {}, { profile = 'GOVERN', bind
   // Second pressure step: non-current changes leave the hot context before the current one.
   const nonCurrentEvicted = budgetNotice(2, 'non-current-changes', 'Changes não atuais omitidas depois das lessons.');
   const currentChange = buildActiveChangeInjection(vaultBase, {
+    context,
     currentOnly: true,
     maxLineChars: INJECTION_LIMITS.lineChars,
   });
@@ -264,6 +277,7 @@ export function buildInjection(vaultBase, input = {}, { profile = 'GOVERN', bind
   const fixed = joinInjection([brain, profileNotice, router, focus, lessonsEvicted, nonCurrentEvicted, currentSummarized]);
   const remaining = Math.max(512, INJECTION_LIMITS.totalBytes - byteLength(fixed) - 1);
   const boundedCurrent = buildActiveChangeInjection(vaultBase, {
+    context,
     currentOnly: true,
     maxBytes: remaining,
     maxLineChars: INJECTION_LIMITS.lineChars,
@@ -285,21 +299,29 @@ if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href)
     const input = readHookInput();
     const runtime = resolveHookOperatingProfile({ input });
     const vaultBase = runtime.vaultBase;
+    const { identity } = runtime;
+    const sid = identity.state === 'resolved'
+      ? identity.canonicalConversationId : (input.session_id || input.sessionId || '');
+    const commandContext = runtime.bindingError ? null : resolveCommandActiveContext({
+      vaultBase,
+      projectRoot: input.cwd || process.cwd(),
+      sessionId: sid,
+      requireExisting: true,
+    });
     writeHookOutput({
       hookSpecificOutput: {
         hookEventName: 'SessionStart',
         additionalContext: buildInjection(vaultBase, input, {
           profile: runtime.profile,
           bindingError: runtime.bindingError,
+          context: commandContext,
         }),
       },
     });
     // Sentinela do change-context: o backlog completo acabou de ser injetado aqui, então o hook
     // UserPromptSubmit não precisa re-pingar no 1º prompt. Bônus — nunca derruba a injeção.
     if (runtime.policy.harness && !runtime.bindingError) try {
-      const st = changeCtxState(vaultBase);
-      const { identity } = runtime;
-      const sid = identity.state === 'resolved' ? identity.canonicalConversationId : (input.session_id || input.sessionId || '');
+      const st = changeCtxState(vaultBase, { context: commandContext });
       if (st) {
         writeSentinel(vaultBase, 'ctx', profileSentinelId(sid, runtime.profile), st.hash);
       }

package/hooks/change-context.mjs

@@ -8,7 +8,9 @@
 import { pathToFileURL } from 'node:url';
 import { readHookInput, writeHookOutput } from './obsidian-common.mjs';
 import { profileRuntimeError } from './brain-inject.mjs';
-import { changeCtxState, readSentinel, renderOpenChanges, writeSentinel } from './change-core.mjs';
+import {
+  activeChange, changeCtxState, readSentinel, renderOpenChanges, writeSentinel,
+} from './change-core.mjs';
 import {
   hookProfilePolicy,
   profileSentinelId,
@@ -43,7 +45,7 @@ export function buildChangePing(vaultBase, sessionId, prompt = '', changeSlug =
       hash,
     };
   }
-  const st = changeCtxState(vaultBase);
+  const st = changeCtxState(vaultBase, { context });
   if (st) {
     if (readSentinel(vaultBase, 'ctx', sentinelId) === st.hash) return null;
     writeSentinel(vaultBase, 'ctx', sentinelId, st.hash);
@@ -75,10 +77,14 @@ if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href)
       vaultBase,
       projectRoot: input.cwd || process.cwd(),
       sessionId: sid,
+      requireExisting: true,
     });
+    const changeSlug = commandContext
+      ? activeChange(vaultBase, { context: commandContext })
+      : (entry?.change_slug || '');
     const ping = runtime.bindingError
       ? { context: profileRuntimeError(runtime.bindingError) }
-      : buildChangePing(vaultBase, sid, input.prompt || '', entry?.change_slug || '', {
+      : buildChangePing(vaultBase, sid, input.prompt || '', changeSlug, {
         profile: runtime.profile,
         context: commandContext,
       });

package/hooks/change-core.mjs

@@ -420,7 +420,8 @@ export function renderOpenChanges(state, {
 // Mantém o nome exportado para consumidores internos existentes, mas agora injeta o backlog
 // completo em vez de ocultar changes não selecionadas.
 export function buildActiveChangeInjection(vaultBase, options = {}) {
-  return renderOpenChanges(allChangesState(vaultBase), options);
+  const { context, ...renderOptions } = options;
+  return renderOpenChanges(allChangesState(vaultBase, { context }), renderOptions);
 }
 
 export function activeChangeLink(vaultBase, { context } = {}) {
@@ -479,8 +480,8 @@ export function writeSentinel(vaultBase, kind, sid, value = '1') {
 // Estado global usado pelo change-context: hash cobre qualquer tarefa aberta, inclusive de uma
 // change que não esteja no ponteiro. As propriedades slug/openTasks preservam compatibilidade com
 // consumidores antigos e descrevem somente a atual.
-export function changeCtxState(vaultBase) {
-  const state = allChangesState(vaultBase);
+export function changeCtxState(vaultBase, { context } = {}) {
+  const state = allChangesState(vaultBase, { context });
   if (!state.changes.length && !state.pointerWarning) return null;
   const selected = state.changes.find((change) => change.current);
   return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wendkeep",
-  "version": "0.76.8",
+  "version": "0.76.9",
   "description": "Vault-first persistent memory for AI coding agents, with an optional profile-aware governance runtime: OFF, FLOW, GUIDE, GOVERN, or ASSURE. Local-first and agent-agnostic (Claude Code, Codex, Cursor…).",
   "type": "module",
   "workspaces": [
@@ -41,7 +41,7 @@
     "node": ">=18"
   },
   "scripts": {
-    "precheck": "node --check src/worktree.mjs && node --check src/context.mjs && node --check src/active-context-health.mjs && node --check packages/vault/src/worktree-metadata.mjs",
+    "precheck": "node --check src/worktree.mjs && node --check src/context.mjs && node --check src/active-context-health.mjs && node --check src/active-context-runtime.mjs && node --check hooks/active-context-store.mjs && node --check hooks/change-core.mjs && node --check hooks/brain-inject.mjs && node --check hooks/change-context.mjs && node --check packages/vault/src/worktree-metadata.mjs",
     "check": "node --check scripts/release.mjs && node --check scripts/release-plan.mjs && node --check scripts/release-provenance.mjs && node --check scripts/run-scope.mjs && node --check src/release-provenance.mjs && node --check bin/wendkeep.mjs && node --check packages/cli/src/index.mjs && node --check src/init.mjs && node --check src/doctor.mjs && node --check src/active-context-health.mjs && node --check src/project-vault.mjs && node --check src/observer-auth.mjs && node --check src/observer-privacy.mjs && node --check src/observer-snapshot.mjs && node --check src/observer-store.mjs && node --check src/observer-memory.mjs && node --check src/observer-memory-publish.mjs && node --check src/observer-sql-store.mjs && node --check src/observer-sql-migrate.mjs && node --check src/observer-sql-publish.mjs && node --check src/observer-transcript-store.mjs && node --check src/observer-server.mjs && node --check src/observer.mjs && node --check src/observer-publish.mjs && node --check src/operating-profile.mjs && node --check src/profile.mjs && node --check src/flow.mjs && node --check src/work-kind.mjs && node --check src/delivery.mjs && node --check web/observer/app.mjs && node --check hooks/observer-publish.mjs && node --check hooks/evidence-context.mjs && node --check hooks/active-context-handoff-evidence.mjs && node --check hooks/evidence-recall.mjs && node --check hooks/memory-scope.mjs && node --check hooks/operating-profile-runtime.mjs && node --check hooks/operating-profile-task-store.mjs && node --check hooks/flow-core.mjs && node --check hooks/flow-protected-policy.mjs && node --check hooks/git-snapshot.mjs && node --check hooks/vault-path-safety.mjs && node --check hooks/vault-runtime-store.mjs && node --check packages/harness/src/index.mjs && node --check packages/harness/src/flow-store.mjs && node --check packages/harness/src/operating-profile.mjs && node --check packages/harness/src/sensors-core.mjs && node --check packages/integrations/src/host-hooks.mjs && node --check packages/integrations/src/hook-envelope.mjs && node --check packages/integrations/src/prompt-content.mjs && node --check packages/integrations/src/transcript-usage.mjs && node --check packages/integrations/src/transcripts.mjs && node --check packages/integrations/src/session-identity.mjs && node --check packages/integrations/src/index.mjs && node --check packages/mcp/src/config.mjs && node --check packages/mcp/src/index.mjs && node --check packages/vault/src/index.mjs && node --check packages/vault/src/project-vault.mjs && node --check packages/vault/src/vault-path-safety.mjs && node --check packages/vault/src/locale.mjs && node --check packages/vault/src/memory-schema.mjs && node --check packages/vault/src/memory-mode.mjs && node --check packages/vault/src/memory-scope.mjs && node --check packages/vault/src/memory-candidate-policy.mjs && node --check packages/vault/src/evidence-recall.mjs && node --check packages/vault/src/memory-handoff.mjs && node --check packages/vault/src/memory-store.mjs && node --check packages/vault/src/validate-core.mjs && node --check packages/vault/src/validate-memory.mjs",
     "test": "node --test --test-concurrency=2",
     "test:core": "node scripts/run-scope.mjs core",

package/src/active-context-runtime.mjs

@@ -1,5 +1,9 @@
 import { readSessionRegistry } from '../hooks/obsidian-common.mjs';
-import { migrateLegacyActiveContext } from '../hooks/active-context-store.mjs';
+import {
+  activeContextRegistryInitialized,
+  migrateLegacyActiveContext,
+  resolveActiveContext,
+} from '../hooks/active-context-store.mjs';
 import { captureProjectScope, compareProjectScopes } from '../hooks/project-scope.mjs';
 import {
   discoverWorktreeRepository,
@@ -107,6 +111,7 @@ export function resolveCommandActiveContext({
   projectRoot = process.cwd(),
   sessionId = '',
   spawn,
+  requireExisting = false,
 } = {}) {
   const requestedSession = String(sessionId || '').trim();
   let identity;
@@ -116,7 +121,7 @@ export function resolveCommandActiveContext({
     });
   } catch (error) {
     const registry = readSessionRegistry(vaultBase);
-    const initialized = Object.keys(registry.active_contexts || {}).length > 0;
+    const initialized = activeContextRegistryInitialized(registry);
     const legacyUnavailable = error?.code === 'WENDKEEP_ACTIVE_CONTEXT_IDENTITY_UNAVAILABLE'
       || (!requestedSession && error?.code === 'WENDKEEP_ACTIVE_CONTEXT_NOT_FOUND');
     if (!initialized && legacyUnavailable) return null;
@@ -127,5 +132,10 @@ export function resolveCommandActiveContext({
       vaultBase, projectRoot, sessionId: candidateId, ...(spawn ? { spawn } : {}),
     }),
   });
+  if (requireExisting) {
+    const registry = readSessionRegistry(vaultBase);
+    if (!activeContextRegistryInitialized(registry)) return null;
+    resolveActiveContext(vaultBase, identity);
+  }
   return identity;
 }