wendkeep 0.28.1 → 0.29.2

package/CHANGELOG.md

@@ -4,6 +4,48 @@ 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.29.2] — 2026-07-09
+
+### Fixed
+- **Iteration turn marker renamed `codex-turn` → `wk-turn`** (provider-neutral). A **Claude**
+  session's iterations carried `<!-- codex-turn: … -->` — a legacy name from when this was a
+  Codex-only tool, confusing in the note source. The marker is a dedup key, so the change is
+  backward-compatible: `hasTurnMarker` still recognizes the legacy name, and `insertIteration`
+  **self-migrates** any `codex-turn` → `wk-turn` on the next write (backfill re-processes older
+  notes). Shared helpers `turnMarker` / `hasTurnMarker` / `normalizeTurnMarkers` in obsidian-common;
+  `vault-health` recognizes both.
+- Note-visible fallback text "Checkpoint registrado pelo hook Stop do **Codex**" → provider-neutral.
+- Stderr log prefix `[codex-obsidian]` → `[wendkeep]` across the hooks.
+
+## [0.29.1] — 2026-07-09
+
+### Added
+- **`wendkeep import --rescan-decisions`** — re-scan **already-imported/captured** transcripts for
+  prose decisions only (no session re-import). For sessions imported before 0.29.0 whose rollouts
+  carry options-in-prose choices that were never captured. Walks the registry
+  (`session_file` + `transcript_path`), runs the same conservative extraction, dedupes by filename
+  — re-running is a no-op. `--limit N` / `--json` supported. New `rescanDecisions()` export.
+
+## [0.29.0] — 2026-07-09
+
+Codex decision parity — agnostic prose-decision capture.
+
+### Added
+- **Prose-decision capture** (`extractProseDecisions` / `captureProseDecisions` in
+  `hooks/decision-capture.mjs`, wired inside `createLinkedNotes`): Codex has no
+  `AskUserQuestion`-style tool — the agent asks in **prose**. A conservative pattern (assistant
+  message with ≥2 enumerated options ending in a question + a SHORT user reply) now produces the
+  **same decision note** the Claude hook writes (options + the user's choice, in `04-Decisões/`,
+  wikilinked to the session). One integration point covers **live Stop, `import` and backfill,
+  for every provider**. Validated on 144 real Codex rollouts: 6 genuine decisions extracted, no
+  visible false positives.
+
+### Notes (investigated, decided against)
+- **Codex subagent telemetry**: real rollouts contain **no** subagent/parallel structure — nothing
+  to map; documented as not applicable.
+- **Codex structured events** (`thread_goal_updated`, `task_complete`): goal payload ≈ the initial
+  prompt; task events are turn markers already parsed. No extra capture worth the noise.
+
 ## [0.28.1] — 2026-07-09
 
 Startup-contention fixes — root-caused from a real VSCode startup log where the memory injection

package/bin/wendkeep.mjs

@@ -54,6 +54,7 @@ Usage:
   wendkeep import [opts]       Backfill: import this project's past Claude + Codex sessions into
                            the vault (deduped by session_id). --source all|claude|codex (default
                            all) · --stamp-ids (backfill session_id in existing notes) ·
+                           --rescan-decisions (capture prose decisions from already-imported transcripts) ·
                            --from <dir> · --codex-from <dir> · --since <date> · --limit N ·
                            --dry-run · --json.
   wendkeep verify [--deep] [--change s]  Run a change's task sensors + record evidence (the gate);

package/hooks/decision-capture.mjs

@@ -68,6 +68,59 @@ ${blocks}
 `;
 }
 
+// --- agnostic prose decisions (Codex parity) ---------------------------------
+// Codex has no AskUserQuestion-style tool: the agent asks in PROSE and the user answers in the
+// next message. Conservative extraction (validated on real rollouts): an assistant message with
+// >=2 enumerated options that ends in a question, followed by a SHORT user reply (a choice, not a
+// new instruction). Works over the turn conversations both parsers already build — so it covers
+// Claude and Codex, live and import, without depending on any hook event.
+export function extractProseDecisions(tx) {
+  const flat = [];
+  for (const t of tx?.turns || []) for (const c of t.conversation || []) flat.push(c);
+  const out = [];
+  for (let i = 0; i < flat.length - 1; i++) {
+    const q = flat[i]; const a = flat[i + 1];
+    if (q.role !== 'Assistente' || a.role !== 'Usuário') continue;
+    const text = String(q.text || '');
+    const answer = String(a.text || '').trim();
+    if (!answer || answer.length > 200) continue; // long reply = new instruction, not a choice
+    // question: the message's last non-empty lines must end with '?'
+    const lines = text.trim().split('\n').map((l) => l.trim()).filter(Boolean);
+    const lastLine = lines[lines.length - 1] || '';
+    if (!/\?\s*$/.test(lastLine)) continue;
+    // options: numbered/lettered lines, or bulleted bold labels
+    let options = [...text.matchAll(/^\s*(?:\d+[\).]|[a-cA-C][\)])\s+(.{3,140})$/gm)].map((m) => m[1].trim());
+    if (options.length < 2) options = [...text.matchAll(/^\s*[-*]\s+\*\*(.{2,90}?)\*\*/gm)].map((m) => m[1].trim());
+    if (options.length < 2) continue;
+    const question = lines.filter((l) => /\?\s*$/.test(l)).pop() || lastLine;
+    out.push({ question: question.slice(0, 200), options: options.slice(0, 6), answer });
+  }
+  return out;
+}
+
+// Write one decision note per extracted prose decision (same shape as the hook capture).
+// Deduped by filename (day + question slug). Returns the vault-relative paths written.
+export function captureProseDecisions(vaultBase, { tx, dateStr, sessionRel, provider, localeId }) {
+  const written = [];
+  const decisions = extractProseDecisions(tx);
+  if (!decisions.length) return written;
+  const loc = getLocale(vaultBase);
+  const dir = join(vaultBase, monthFolderRelFromDateStr(loc.folders.decisions, dateStr, vaultBase));
+  for (const d of decisions) {
+    ensureDir(dir);
+    const filePath = join(dir, `${dateStr}-escolha-${slugify(d.question, 'decisao', 50)}.md`);
+    if (existsSync(filePath)) continue;
+    writeFileSync(filePath, buildDecisionCaptureNote({
+      questions: [{ question: d.question, multiSelect: false, options: d.options.map((label) => ({ label, description: '' })) }],
+      answers: { [d.question]: d.answer },
+      dateStr, startedAt: `${dateStr}T00:00:00`, sessionRel,
+      provider: provider || providerMeta(tx?.provider), localeId: localeId || loc.id,
+    }), 'utf-8');
+    written.push(toVaultRelative(vaultBase, filePath));
+  }
+  return written;
+}
+
 export function captureDecision(vaultBase, input) {
   const toolIn = input.tool_input || input.toolInput || {};
   const questions = Array.isArray(toolIn.questions) ? toolIn.questions : [];

package/hooks/import-sessions.mjs

@@ -18,8 +18,9 @@ import { buildSessionContent, allocateSessionPath } from './session-start.mjs';
 import { createLinkedNotes } from './linked-notes.mjs';
 import { updateSessionUsage } from './token-usage.mjs';
 import { upsertSubagentUsage } from './subagent-usage.mjs';
-import { readSessionRegistry, upsertSessionRegistry, formatLocalIso, formatDate } from './obsidian-common.mjs';
+import { readSessionRegistry, upsertSessionRegistry, formatLocalIso, formatDate, providerMeta } from './obsidian-common.mjs';
 import { getLocale } from './locale.mjs';
+import { captureProseDecisions } from './decision-capture.mjs';
 
 // Claude encodes a project's absolute path as its `.claude/projects` dir name by replacing each
 // path separator and the drive colon with '-'. `C:\GitHub\WendKeep` -> `C--GitHub-WendKeep`.
@@ -237,6 +238,37 @@ export function importSession(vaultBase, txPath, opts = {}) {
   return { sessionId, relPath, turns: turns.length };
 }
 
+// Re-scan ALREADY-imported/captured transcripts for prose decisions only (no session re-import).
+// For sessions imported before 0.29.0, whose transcripts carry options-in-prose choices that were
+// never captured. Walks the registry (session_file + transcript_path), parses each transcript and
+// runs captureProseDecisions — filename-deduped, so re-running is a no-op. Fail-soft per session.
+export function rescanDecisions(vaultBase, { limit = 0 } = {}) {
+  const sessions = readSessionRegistry(vaultBase).sessions || {};
+  const report = { scanned: 0, decisions: 0, errors: [], sessions: [] };
+  let done = 0;
+  for (const [sessionId, entry] of Object.entries(sessions)) {
+    if (!entry?.transcript_path || !entry.session_file) continue;
+    if (!existsSync(entry.transcript_path)) continue;
+    if (limit && done >= limit) break;
+    report.scanned += 1;
+    done += 1;
+    try {
+      const tx = parseTranscript(entry.transcript_path);
+      const dateStr = String(entry.started_at || entry.ended_at || '').slice(0, 10) || formatDate(new Date());
+      const written = captureProseDecisions(vaultBase, {
+        tx, dateStr, sessionRel: entry.session_file, provider: providerMeta(tx.provider),
+      });
+      if (written.length) {
+        report.decisions += written.length;
+        report.sessions.push({ sessionId, notes: written });
+      }
+    } catch (error) {
+      report.errors.push({ sessionId, error: error.message });
+    }
+  }
+  return report;
+}
+
 // Stamp a missing/empty `session_id` into a note's frontmatter (only within the frontmatter
 // block, right after `provider:`). Leaves a note that already has a non-empty id untouched.
 function injectSessionIdFrontmatter(content, sessionId) {

package/hooks/linked-notes.mjs

@@ -13,6 +13,7 @@ import {
   wikilinkFromRel,
 } from './obsidian-common.mjs';
 import { getLocale } from './locale.mjs';
+import { captureProseDecisions } from './decision-capture.mjs';
 
 function yamlQuote(value) {
   return `"${String(value || '').replaceAll('"', '\\"')}"`;
@@ -568,6 +569,14 @@ export function createLinkedNotes(vaultBase, dateStr, sessionRel, tx, options =
     }
   }
 
+  // Agnostic prose decisions (Codex parity): options-in-prose + short answer -> decision note.
+  // One integration point covers live Stop, import and backfill, for every provider. Fail-quiet.
+  try {
+    for (const rel of captureProseDecisions(vaultBase, { tx, dateStr, sessionRel, provider, localeId: loc.id })) {
+      linked.decisions.push(rel);
+    }
+  } catch { /* prose capture é bônus — nunca derruba a captura principal */ }
+
   const learnings = extractLearningDetails(tx, bugDetails);
   if (learnings) {
     const vaultLearningKeys = collectLearningKeys(vaultBase); // vault-wide dedup

package/hooks/obsidian-common.mjs

@@ -557,6 +557,27 @@ export function wikilinkFromRel(relPath) {
   return `[[${relPath.replace(/\.md$/i, '').replaceAll('\\', '/')}]]`;
 }
 
+// Per-iteration dedup marker (an invisible HTML comment). Provider-neutral name `wk-turn`; the
+// old `codex-turn` (legacy, from when this was a Codex-only tool) is still RECOGNIZED so notes
+// written by older versions keep deduping, and normalizeTurnMarkers migrates them on the next write.
+export const TURN_MARKER = 'wk-turn';
+export const LEGACY_TURN_MARKERS = ['codex-turn'];
+
+export function turnMarker(id) {
+  return `<!-- ${TURN_MARKER}: ${id} -->`;
+}
+
+export function hasTurnMarker(content, id) {
+  return [TURN_MARKER, ...LEGACY_TURN_MARKERS].some((m) => String(content || '').includes(`<!-- ${m}: ${id} -->`));
+}
+
+// Rewrite any legacy turn markers in a note to the current name (self-healing migration).
+export function normalizeTurnMarkers(content) {
+  let c = String(content || '');
+  for (const m of LEGACY_TURN_MARKERS) c = c.replaceAll(`<!-- ${m}: `, `<!-- ${TURN_MARKER}: `);
+  return c;
+}
+
 export function listMarkdownFiles(dir) {
   try {
     return readdirSync(dir).filter((f) => f.endsWith('.md'));

package/hooks/session-backfill.mjs

@@ -36,7 +36,9 @@ function parseArgs(argv) {
 }
 
 function hasTurnMarker(content, turnId) {
-  return content.includes(`<!-- codex-turn: ${turnId} -->`);
+  // recognize both the current `wk-turn` and the legacy `codex-turn`
+  return content.includes(`<!-- wk-turn: ${turnId} -->`)
+    || content.includes(`<!-- codex-turn: ${turnId} -->`);
 }
 
 function sessionEntries(vaultBase, args) {
@@ -135,7 +137,7 @@ if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href)
   try {
     main();
   } catch (error) {
-    process.stderr.write(`[codex-obsidian] Backfill falhou: ${error.message}\n`);
+    process.stderr.write(`[wendkeep] Backfill falhou: ${error.message}\n`);
     process.exitCode = 1;
   }
 }

package/hooks/session-ensure.mjs

@@ -387,6 +387,6 @@ function main() {
 try {
   main();
 } catch (error) {
-  process.stderr.write(`[codex-obsidian] UserPromptSubmit falhou: ${error.message}\n`);
+  process.stderr.write(`[wendkeep] UserPromptSubmit falhou: ${error.message}\n`);
   writeHookOutput({});
 }

package/hooks/session-start.mjs

@@ -161,7 +161,7 @@ function main() {
   try {
     sweepStaleSessionsFile(vaultBase, now, undefined, input.transcript_path || input.transcriptPath || '');
   } catch (error) {
-    process.stderr.write(`[codex-obsidian] sweep de sessões falhou: ${error.message}\n`);
+    process.stderr.write(`[wendkeep] sweep de sessões falhou: ${error.message}\n`);
   }
 
   // Reuso da nota apontada pelo CURRENT_SESSION só quando é a MESMA conversa
@@ -309,9 +309,9 @@ if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href)
   try {
     main();
   } catch (error) {
-    process.stderr.write(`[codex-obsidian] SessionStart falhou: ${error.message}\n`);
+    process.stderr.write(`[wendkeep] SessionStart falhou: ${error.message}\n`);
     writeHookOutput({
-      systemMessage: `[codex-obsidian] Não foi possível criar a sessão Obsidian: ${error.message}`,
+      systemMessage: `[wendkeep] Não foi possível criar a sessão Obsidian: ${error.message}`,
     });
   }
 }

package/hooks/session-stop.mjs

@@ -30,6 +30,9 @@ import {
   wikilinkFromRel,
   writeControl,
   writeHookOutput,
+  turnMarker,
+  hasTurnMarker,
+  normalizeTurnMarkers,
 } from './obsidian-common.mjs';
 
 function extractContentText(content) {
@@ -596,7 +599,7 @@ export function buildIterationBlock(tx, input) {
   // inclui recortes da conversa do turno, sem despejar outputs brutos.
   return `
 ### ${formatTimeForHeading(now)} - ${heading}
-<!-- codex-turn: ${turnId} -->
+${turnMarker(turnId)}
 
 **Pedido:** ${compactText(promptText, 1000)}
 
@@ -609,7 +612,7 @@ ${formatConversation(turn)}
 
 **Arquivos detectados no turno:** ${formatInlineList(files, 'Nenhum arquivo detectado automaticamente.')}
 
-**Estado ao final do turno:** ${compactText(latestAssistant || 'Checkpoint registrado pelo hook Stop do Codex.', 900)}
+**Estado ao final do turno:** ${compactText(latestAssistant || 'Checkpoint registrado automaticamente ao final do turno.', 900)}
 `;
 }
 
@@ -751,17 +754,19 @@ function relocateOrphanIterations(content) {
 }
 
 export function insertIteration(sessionPath, block, turnId, tx) {
-  let content = readFileSync(sessionPath, 'utf-8');
-  if (content.includes(`<!-- codex-turn: ${turnId} -->`)) {
+  const original = readFileSync(sessionPath, 'utf-8');
+  // Self-heal: migrate any legacy `codex-turn` markers to the neutral name on this write.
+  let content = normalizeTurnMarkers(original);
+  if (hasTurnMarker(content, turnId)) {
     // Turno já registrado: ainda assim repara órfãos e seções dedicadas.
     const repaired = applyDedicatedSections(relocateOrphanIterations(content), tx);
-    if (repaired !== content) writeFileSync(sessionPath, repaired, 'utf-8');
+    if (repaired !== original) writeFileSync(sessionPath, repaired, 'utf-8');
     return false;
   }
   content = relocateOrphanIterations(content);
   content = insertIntoIteracoes(content, block);
   content = applyDedicatedSections(content, tx);
-  writeFileSync(sessionPath, content, 'utf-8');
+  if (content !== original) writeFileSync(sessionPath, content, 'utf-8');
   return true;
 }
 
@@ -1037,7 +1042,7 @@ function main() {
   try {
     applyLinearLinks(sessionPath, tx, vaultBase, sessionRel);
   } catch (error) {
-    process.stderr.write(`[codex-obsidian] Linear link falhou: ${error.message}\n`);
+    process.stderr.write(`[wendkeep] Linear link falhou: ${error.message}\n`);
   }
 
   try {
@@ -1048,7 +1053,7 @@ function main() {
       transcriptPath,
     });
   } catch (error) {
-    process.stderr.write(`[codex-obsidian] Token usage falhou: ${error.message}\n`);
+    process.stderr.write(`[wendkeep] Token usage falhou: ${error.message}\n`);
   }
 
   // Subagent/workflow telemetry (0.10.0): fold sibling subagent transcripts into the note.
@@ -1056,7 +1061,7 @@ function main() {
   try {
     upsertSubagentUsage(sessionPath, transcriptPath);
   } catch (error) {
-    process.stderr.write(`[codex-obsidian] Subagent usage falhou: ${error.message}\n`);
+    process.stderr.write(`[wendkeep] Subagent usage falhou: ${error.message}\n`);
   }
 
   if (!shouldFinalizeSession()) {
@@ -1127,7 +1132,7 @@ function main() {
     const rows = buildBrainIndex(vaultBase);
     buildBrainDigest(vaultBase, rows);
   } catch (error) {
-    process.stderr.write(`[codex-obsidian] brain index/digest falhou: ${error.message}\n`);
+    process.stderr.write(`[wendkeep] brain index/digest falhou: ${error.message}\n`);
   }
 
   pingObsidianVault(input.obsidian_api_key);
@@ -1138,7 +1143,7 @@ if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href)
   try {
     main();
   } catch (error) {
-    process.stderr.write(`[codex-obsidian] Stop falhou: ${error.message}\n`);
+    process.stderr.write(`[wendkeep] Stop falhou: ${error.message}\n`);
     writeHookOutput({});
   }
 }

package/hooks/token-usage.mjs

@@ -966,7 +966,7 @@ if (process.argv[1] && fileURLToPath(import.meta.url) === process.argv[1]) {
   try {
     runCli();
   } catch (error) {
-    process.stderr.write(`[codex-obsidian] Token usage falhou: ${error.message}\n`);
+    process.stderr.write(`[wendkeep] Token usage falhou: ${error.message}\n`);
     process.exitCode = 1;
   }
 }

package/hooks/vault-health.mjs

@@ -39,7 +39,7 @@ function parseArgs(argv) {
 function findDuplicateTurnMarkers(content) {
   const seen = new Set();
   const duplicated = new Set();
-  const regex = /<!-- codex-turn: ([^>]+) -->/g;
+  const regex = /<!-- (?:wk-turn|codex-turn): ([^>]+) -->/g;
   let match;
   while ((match = regex.exec(content)) !== null) {
     const turnId = match[1].trim();
@@ -104,10 +104,10 @@ function checkSession({ vaultBase, sessionRel, control, registry }) {
 
   const content = readFileSync(sessionPath, 'utf-8');
   const duplicates = findDuplicateTurnMarkers(content);
-  metrics.turnMarkers = (content.match(/<!-- codex-turn:/g) || []).length;
+  metrics.turnMarkers = (content.match(/<!-- (?:wk-turn|codex-turn):/g) || []).length;
   metrics.duplicateTurnMarkers = duplicates.length;
 
-  if (duplicates.length) failures.push(`Marcadores codex-turn duplicados: ${duplicates.join(', ')}`);
+  if (duplicates.length) failures.push(`Marcadores de turno duplicados: ${duplicates.join(', ')}`);
   if (hasHeadingAfterClosing(content)) failures.push('Há headings/iterações após ## Encerramento.');
   if (!usageSectionIsPlaced(content)) failures.push('## Uso de tokens e custos está fora da posição esperada.');
   if (hasDefaultPending(content)) warnings.push('Pendências ainda contém placeholders padrão.');
@@ -197,7 +197,7 @@ if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href)
   try {
     main();
   } catch (error) {
-    process.stderr.write(`[codex-obsidian] Vault health falhou: ${error.message}\n`);
+    process.stderr.write(`[wendkeep] Vault health falhou: ${error.message}\n`);
     process.exitCode = 1;
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wendkeep",
-  "version": "0.28.1",
+  "version": "0.29.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": {

package/src/import.mjs

@@ -3,7 +3,7 @@
 // by session_id). One command backfills your whole history: cost, subagents, iterations.
 import { existsSync } from 'node:fs';
 import { isAbsolute, resolve } from 'node:path';
-import { runImport, stampSessionIds } from '../hooks/import-sessions.mjs';
+import { runImport, stampSessionIds, rescanDecisions } from '../hooks/import-sessions.mjs';
 
 function opt(argv, name) {
   const i = argv.indexOf(name);
@@ -18,6 +18,16 @@ export function runImportCli(argv) {
   const vaultBase = isAbsolute(vaultRaw) ? vaultRaw : resolve(process.cwd(), vaultRaw);
   if (!existsSync(vaultBase)) { process.stderr.write(`wendkeep import: vault not found: ${vaultBase}\n`); process.exit(2); }
 
+  // Repair mode: re-scan already-imported transcripts for prose decisions only, then stop.
+  if (argv.includes('--rescan-decisions')) {
+    const r = rescanDecisions(vaultBase, { limit: Number(opt(argv, '--limit')) || 0 });
+    if (argv.includes('--json')) { process.stdout.write(`${JSON.stringify(r, null, 2)}\n`); process.exit(0); }
+    process.stdout.write(`${r.scanned} transcript(s) varridos · ${r.decisions} decisão(ões) capturadas\n`);
+    for (const s of r.sessions) for (const n of s.notes) process.stdout.write(`  → ${n}\n`);
+    if (r.errors.length) for (const e of r.errors) process.stderr.write(`  erro ${e.sessionId}: ${e.error}\n`);
+    process.exit(0);
+  }
+
   // Repair mode: backfill session_id into existing notes from the registry, then stop.
   if (argv.includes('--stamp-ids')) {
     const r = stampSessionIds(vaultBase);