wendkeep 0.46.1 → 0.46.2

package/CHANGELOG.md

@@ -4,6 +4,40 @@ 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.46.2] — 2026-07-19
+
+### Fixed
+
+- **Rollout de subagent do Codex virava sessão top-level no import.** Um subagent do Codex
+  não é um arquivo em `<transcript>/subagents/` — é um rollout **irmão** no
+  `~/.codex/sessions/`, cujo `session_meta` declara `source.subagent` e aponta pro pai via
+  `parent_thread_id`. O import ignorava o marcador e materializava o subagent como uma
+  "sessão" própria, com o contexto do pai inteiro replicado (subagent herda o histórico) —
+  no caso real, uma nota fantasma de 23 turnos duplicando a conversa da sessão-mãe. Agora a
+  descoberta expõe o marcador, o import conta subagents à parte no relatório (nunca em
+  `skipped`) e nenhuma nota é criada. A entrada de registry que o import antigo escreveu
+  para um subagent é removida — self-healing do nosso próprio dado errado, nunca limpeza
+  genérica: entrada com o mesmo id mas transcript diferente é preservada.
+- **Telemetria de subagent do Codex nunca chegava à sessão-mãe — nem ao vivo.** A descoberta
+  (`collectSubagentUsage`) era Claude-shaped: procurava um diretório `subagents/` ao lado do
+  transcript, que no Codex não existe. Resultado: toda sessão Codex fechava com
+  `subagents_count: 0`, tanto no import quanto no hook vivo `SubagentStop` wirado na 0.46.0
+  — o custo dos subagents simplesmente não existia no vault. A nova
+  `collectCodexSubagentUsage` acha os irmãos por `parent_thread_id` (no dia do rollout pai e
+  no dia seguinte, cobrindo spawn que cruza a meia-noite UTC — o caso real passou a seis
+  minutos disso) e devolve o mesmo agregado que o writer já consome: vivo e import passam a
+  atribuir pelo mesmo caminho.
+- **O bloco injetado ainda aparecia como fala do usuário no "Contexto conversado".** O fix
+  da 0.46.1 protegeu o título, mas a linha `**Usuário:**` da iteração vinha de um segundo
+  filtro (`shouldIgnoreUserText`) que duplicava por cópia a lista do `isBootstrapPrompt` — e
+  as cópias divergiram. O filtro agora delega: um lugar só para o próximo bloco que o
+  harness inventar.
+- Bytes NUL literais em `hooks/token-usage.mjs` e `hooks/subagent-usage.mjs` escapados —
+  mesma classe do fix de `taxonomy.mjs` (#7): o byte cru fazia o `file` classificar o fonte
+  como binário e o ripgrep pulá-lo em silêncio. Entrou `tests/source-hygiene.test.mjs`
+  barrando byte de controle em qualquer fonte publicado; ele pegou uma quarta ocorrência
+  introduzida durante esta própria mudança.
+
 ## [0.46.1] — 2026-07-19
 
 ### Fixed

package/hooks/import-sessions.mjs

@@ -17,7 +17,7 @@ import {
 import { buildSessionContent, allocateSessionPath } from './session-start.mjs';
 import { createLinkedNotes } from './linked-notes.mjs';
 import { updateSessionObservability } from './session-observability.mjs';
-import { readSessionRegistry, upsertSessionRegistry, formatLocalIso, formatDate, providerMeta, isBootstrapPrompt } from './obsidian-common.mjs';
+import { readSessionRegistry, upsertSessionRegistry, removeSessionRegistryEntry, formatLocalIso, formatDate, providerMeta, isBootstrapPrompt } from './obsidian-common.mjs';
 import { getLocale } from './locale.mjs';
 import { captureProseDecisions } from './decision-capture.mjs';
 
@@ -192,7 +192,12 @@ export function discoverCodexTranscripts(projectPath, fromDir) {
     const meta = readSessionMeta(path);
     if (!meta || !meta.id) continue;
     if (projectPath && !cwdMatchesProject(meta.cwd, projectPath)) continue;
-    transcripts.push({ path, sessionId: meta.id, cwd: meta.cwd || '' });
+    // A subagent thread's rollout is a SIBLING file of its parent's — same dir, own id. The
+    // meta says what the file IS; ignoring it turned hierarchy into a duplicate session note.
+    const subagent = meta.source?.subagent
+      ? { parentThreadId: meta.parent_thread_id || meta.source.subagent.thread_spawn?.parent_thread_id || '', nickname: meta.source.subagent.thread_spawn?.agent_nickname || '' }
+      : null;
+    transcripts.push({ path, sessionId: meta.id, cwd: meta.cwd || '', subagent });
   }
   return { dir, transcripts };
 }
@@ -350,10 +355,21 @@ export function runImport(vaultBase, opts = {}) {
   }
   const notes = capturedSessionNotes(vaultBase);
   const sinceMs = since ? Date.parse(since) : 0;
-  const report = { source: src, claudeDir, codexDir, scanned: transcripts.length, imported: 0, repaired: 0, skipped: 0, errors: [], sessions: [] };
+  const report = { source: src, claudeDir, codexDir, scanned: transcripts.length, imported: 0, repaired: 0, skipped: 0, subagents: 0, errors: [], sessions: [] };
 
   let done = 0;
   for (const t of transcripts) {
+    // A subagent rollout is telemetry of its PARENT session, never a session of its own —
+    // importing it materialized the parent's replayed context as a ghost note. Counted apart
+    // from `skipped` (which means "session already covered"). If import <=0.46.1 registered
+    // it as a top-level session, that entry is our own bad write: heal it.
+    if (t.subagent) {
+      report.subagents++;
+      if (!dryRun) {
+        try { removeSessionRegistryEntry(vaultBase, t.sessionId, t.path); } catch { /* best-effort */ }
+      }
+      continue;
+    }
     if (limit && done >= limit) break;
 
     // Every transcript is parsed now, including already-captured ones: partial coverage is

package/hooks/obsidian-common.mjs

@@ -355,6 +355,25 @@ function meaningfulPatch(patch = {}) {
   }));
 }
 
+// Remove one registry entry, but ONLY when its transcript matches the given path — this is
+// self-healing for entries wendkeep itself mis-wrote (a subagent rollout registered as a
+// top-level session by import <=0.46.1), never generic registry cleanup. An entry with the
+// same id but a different transcript belongs to someone else's state and is preserved.
+export function removeSessionRegistryEntry(vaultBase, sessionId, transcriptPath) {
+  if (!sessionId) return false;
+  let removed = false;
+  mutateSessionRegistry(vaultBase, (registry) => {
+    const entry = registry.sessions[sessionId];
+    if (!entry) return null;
+    const paths = [...(Array.isArray(entry.transcript_paths) ? entry.transcript_paths : []), entry.transcript_path].filter(Boolean);
+    if (!paths.some((p) => transcriptsMatch(p, transcriptPath))) return null;
+    delete registry.sessions[sessionId];
+    removed = true;
+    return null;
+  });
+  return removed;
+}
+
 export function upsertSessionRegistry(vaultBase, sessionId, patch) {
   if (!sessionId) return null;
   const clean = meaningfulPatch(patch);

package/hooks/session-observability.mjs

@@ -1,7 +1,7 @@
 // Single atomic writer for session usage, models, reasoning/effort and subagents.
 import { existsSync, readFileSync, writeFileSync } from 'node:fs';
 import { collectSessionUsage } from './token-usage.mjs';
-import { collectSubagentUsage, sessionDirFromTranscript } from './subagent-usage.mjs';
+import { collectSubagentUsage, collectCodexSubagentUsage, sessionDirFromTranscript } from './subagent-usage.mjs';
 import { inspectTranscriptIdentity } from './session-identity.mjs';
 
 const HEADING = '## Agentes, tokens e custos';
@@ -137,7 +137,11 @@ ${renderSubagents(subagents)}`;
 export function buildSessionObservability({ sessionContent, transcriptPath }) {
   const main = collectSessionUsage({ sessionContent, transcriptPath });
   if (!main) return null;
-  const subagents = collectSubagentUsage(sessionDirFromTranscript(transcriptPath));
+  // Claude layout first (<transcript>/subagents/); when absent, the Codex layout — sibling
+  // rollouts linked by parent_thread_id. The Codex collector self-gates: a Claude transcript
+  // has no session_meta line, so it returns null and this stays a strict fallback.
+  const subagents = collectSubagentUsage(sessionDirFromTranscript(transcriptPath))
+    || collectCodexSubagentUsage(transcriptPath);
   const ledger = [...mainLedger(main), ...subagentLedger(subagents)];
   const sub = subagents?.aggregate || { count: 0, tokens: 0, cost: 0, wasted: 0, tools: [] };
   let content = main.content;

package/hooks/session-stop.mjs

@@ -18,6 +18,7 @@ import {
   formatLocalIso,
   getNextAdrNumber,
   getVaultBase,
+  isBootstrapPrompt,
   warnIfDefaultVault,
   listMarkdownFiles,
   readControl,
@@ -53,11 +54,12 @@ const SYNTHETIC_EVENT_TAG = /^<\/?(?:task-notification|system-reminder|local-com
 
 function shouldIgnoreUserText(text) {
   const trimmed = String(text || '').trim();
+  // Bootstrap detection is DELEGATED, not copied: this used to duplicate isBootstrapPrompt's
+  // prefix list and the copies drifted — <recommended_plugins> made it into one and not the
+  // other, so the title came out clean while the same block still showed as "Usuário" in the
+  // conversation context. One filter, one place to add the next injected block.
   return SYNTHETIC_EVENT_TAG.test(trimmed)
-    || /^# AGENTS\.md instructions/.test(trimmed)
-    || trimmed.startsWith('<permissions instructions>')
-    || trimmed.includes('You are Codex, a coding agent')
-    || trimmed.startsWith('## Memory')
+    || isBootstrapPrompt(trimmed)
     // Harness utility meta-prompts (title generation, classifiers) — not real user turns; they
     // were leaking into note titles/summaries on import.
     || /^Generate a concise( UI)? title/i.test(trimmed)

package/hooks/subagent-usage.mjs

@@ -76,6 +76,109 @@ const round4 = (n) => Math.round((Number(n) || 0) * 10000) / 10000;
 
 // Aggregate every subagent transcript under <sessionDir>/subagents. null when the dir is
 // absent (Codex / a session with no subagents) or nothing parseable.
+// --- Codex discovery ----------------------------------------------------------
+// A Codex subagent is not a file under `<transcript>/subagents/` — it is a SIBLING rollout
+// in ~/.codex/sessions/YYYY/MM/DD/, whose session_meta declares source.subagent and points
+// back via parent_thread_id. Without this, every Codex session closed with subagents_count 0,
+// live (SubagentStop) and on import alike.
+
+// First line of a rollout, bounded — Codex meta lines can be large (env, git, instructions).
+function readRolloutMeta(path, maxBytes = 4 * 1024 * 1024) {
+  try {
+    const text = readFileSync(path, 'utf-8');
+    if (text.length > maxBytes) return null;
+    const line = text.slice(0, text.indexOf('\n') === -1 ? text.length : text.indexOf('\n'));
+    const e = JSON.parse(line);
+    return e.type === 'session_meta' ? (e.payload || {}) : null;
+  } catch { return null; }
+}
+
+// Sibling day dirs to scan: the parent rollout's own dir plus the NEXT day — a session that
+// crosses midnight UTC spawns its subagent in the other day's folder, and the first real case
+// (Vendiva, 23:54 UTC) missed that by six minutes.
+function codexSiblingDirs(transcriptPath) {
+  const dir = join(transcriptPath, '..');
+  const m = String(dir).replace(/[\\/]+$/, '').match(/(\d{4})[\\/](\d{2})[\\/](\d{2})$/);
+  if (!m) return [dir];
+  const next = new Date(Date.UTC(Number(m[1]), Number(m[2]) - 1, Number(m[3]) + 1));
+  const pad = (n) => String(n).padStart(2, '0');
+  const nextDir = join(dir, '..', '..', '..', String(next.getUTCFullYear()), pad(next.getUTCMonth() + 1), pad(next.getUTCDate()));
+  return [dir, nextDir];
+}
+
+export function collectCodexSubagentUsage(transcriptPath) {
+  const meta = readRolloutMeta(transcriptPath);
+  if (!meta?.id) return null; // not a Codex rollout — the Claude path stays untouched
+  const canonicalId = meta.id;
+
+  const subagents = [];
+  const allTools = new Set();
+  const usageAgg = { input: 0, cached: 0, cacheWrite: 0, output: 0, reasoning: 0, total: 0 };
+  const modelMap = new Map();
+  let count = 0;
+  let calls = 0;
+  let cost = 0;
+
+  for (const dayDir of codexSiblingDirs(transcriptPath)) {
+    let names;
+    try { names = readdirSync(dayDir); } catch { continue; }
+    for (const n of names) {
+      if (!/\.jsonl$/i.test(n)) continue;
+      const f = join(dayDir, n);
+      if (f === transcriptPath) continue;
+      const sib = readRolloutMeta(f);
+      if (!sib?.source?.subagent) continue;
+      const parent = sib.parent_thread_id || sib.source.subagent.thread_spawn?.parent_thread_id || '';
+      if (parent !== canonicalId) continue;
+
+      const summary = summarizeTokenUsage(parseTokenUsageFromTranscript(f));
+      if (!summary.calls) continue;
+      const tokens = tokensTotal(summary.totals);
+      for (const t of summary.tools) allTools.add(t);
+
+      subagents.push({
+        id: String(sib.id || basename(f, '.jsonl')).slice(0, 12),
+        agentType: sib.source.subagent.thread_spawn?.agent_nickname || 'codex-subagent',
+        workflow: null,
+        model: summary.models[0] || '?',
+        effort: summary.pensamento || '',
+        tools: summary.tools.length,
+        toolNames: summary.tools,
+        calls: summary.calls,
+        tokens,
+        cost: round4(summary.costs.model),
+        modelRows: summary.modelRows,
+      });
+
+      for (const row of summary.modelRows || []) {
+        const rowEffort = summary.pensamento || '';
+        const key = `${row.provider || '?'}\u0000${row.model || '?'}\u0000${rowEffort}`;
+        const current = modelMap.get(key) || { provider: row.provider || '?', model: row.model || '?', effort: rowEffort, calls: 0, tokens: 0, cost: 0,
+          usage: { input: 0, cached: 0, cacheWrite: 0, output: 0, reasoning: 0, total: 0 } };
+        current.calls += row.calls || 0;
+        current.tokens += tokensTotal(row.usage);
+        current.cost += row.costs?.model || 0;
+        for (const k of Object.keys(current.usage)) current.usage[k] += row.usage?.[k] || 0;
+        modelMap.set(key, current);
+      }
+
+      count += 1;
+      calls += summary.calls;
+      cost += summary.costs.model;
+      for (const k of Object.keys(usageAgg)) usageAgg[k] += summary.totals[k] || 0;
+    }
+  }
+
+  if (!count) return null;
+  return {
+    subagents,
+    workflows: [],
+    aggregate: { count, calls, tokens: tokensTotal(usageAgg), cost: round4(cost), wasted: 0, usage: usageAgg, tools: [...allTools],
+      modelRows: [...modelMap.values()].map((r) => ({ ...r, cost: round4(r.cost), source: 'subagent' })),
+    },
+  };
+}
+
 export function collectSubagentUsage(sessionDir) {
   const subDir = join(sessionDir, 'subagents');
   if (!existsSync(subDir)) return null;

package/hooks/token-usage.mjs

@@ -612,7 +612,7 @@ const USAGE_FIELDS = ['provider', 'pensamento', 'input', 'cache_write', 'cache_r
 
 export function sameUsageData(a, b) {
   if (!a || !b) return false;
-  const listEqual = (x, y) => (x || []).join('') === (y || []).join('');
+  const listEqual = (x, y) => (x || []).join('\u0000') === (y || []).join('\u0000');
   return USAGE_FIELDS.every((f) => (a[f] ?? null) === (b[f] ?? null))
     && listEqual(a.modelos, b.modelos) && listEqual(a.tools, b.tools);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wendkeep",
-  "version": "0.46.1",
+  "version": "0.46.2",
   "description": "A persistent-memory harness for AI coding agents on your Obsidian vault: turn-by-turn session capture plus a native, zero-dependency spec→change→verify→archive loop (sensor-gated, independent verdict, mutation discrimination). Local-first, agent-agnostic (Claude Code, Codex, Cursor…).",
   "type": "module",
   "bin": {