wendkeep 0.28.1 → 0.29.1

package/CHANGELOG.md

@@ -4,6 +4,35 @@ 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.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/package.json

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