wendkeep 0.16.0 → 0.18.0

package/CHANGELOG.md

@@ -4,6 +4,49 @@ 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.18.0] — 2026-07-06
+
+Session identity in the note.
+
+### Added
+- Session notes now carry **`session_id`** in their frontmatter — both live capture and import,
+  Claude and Codex. Pairs with the existing `provider:` field so every note self-identifies
+  (which conversation, which agent) without consulting the registry.
+- **`wendkeep import --stamp-ids`** — backfill `session_id` into existing notes from the
+  `SESSION_REGISTRY` (for notes captured or imported before the field existed). Idempotent;
+  only touches notes missing the field.
+- Import dedup now also scans existing notes' `session_id` (`capturedSessionIds` = registry ∪
+  note frontmatter), so a session that already has a note on disk is never re-imported even if
+  the registry was reset or lost.
+
+### Changed
+- `buildSessionContent` accepts a `sessionId`; the SessionStart hook (all three create/recreate
+  paths) and `importSession` thread the id through, so a note records its identity at creation.
+
+## [0.17.0] — 2026-07-06
+
+Retroactive memory, now agent-agnostic (Codex).
+
+### Added
+- **`wendkeep import --source codex|all`** — import now covers **Codex** too. Codex rollouts
+  (`~/.codex/sessions/**`) aren't organized by project, so they're scoped by the `cwd` recorded
+  in each session's `session_meta` — matched case- and separator-insensitively, including
+  subdirectories. `--source` defaults to **`all`** (both agents); narrow with `claude` / `codex`.
+  `--codex-from <dir>` overrides the sessions root.
+- Transcript parsers now carry a `provider` field, so an imported note is tagged with the
+  transcript's **real** provider (`provider: codex` for Codex) instead of the ambient default.
+
+### Changed
+- `wendkeep import` default source is now **`all`** (was Claude-only in 0.16.0). Still idempotent —
+  already-imported sessions are skipped by `session_id`, per project (Claude by slug dir, Codex by
+  `session_meta.cwd`).
+- Import registration keys off the **discovered** `session_id` (filename for Claude,
+  `session_meta.id` for Codex) so the dedup key and the registry key are always identical —
+  closes a latent duplicate-on-reimport gap if a transcript's filename ever diverged from its
+  internal id.
+- Validated on real data: **24** Codex sessions discovered for a production project (across
+  drive-case variants), 0 parse errors, notes correctly tagged `codex`.
+
 ## [0.16.0] — 2026-07-06
 
 Retroactive memory.

package/README.md

@@ -95,7 +95,7 @@ No re‑copying, no snapshot to re‑sync — the package is the single source o
 | `wendkeep spec <sub>` | Living specs: `list` / `show <capability>`. |
 | `wendkeep sensors <sub>` | `list` / `add <id> "<command>"` — view/edit `wendkeep.sensors.json` (JSON Schema shipped). |
 | `wendkeep cost [--since d]` | Aggregate AI-coding spend across the vault's sessions — total, by model, by day (`--json`). |
-| `wendkeep import [opts]` | **Retroactive memory** — backfill past Claude sessions into the vault (deduped by `session_id`). `--from <dir>` / `--since d` / `--limit n` / `--dry-run` / `--json`. |
+| `wendkeep import [opts]` | **Retroactive memory** — backfill past **Claude + Codex** sessions into the vault (deduped by `session_id`). `--source all\|claude\|codex` / `--from <dir>` / `--codex-from <dir>` / `--since d` / `--limit n` / `--dry-run` / `--json`. |
 | `wendkeep lesson add "t" "l"` | Record a project-local lesson (injected at the next SessionStart). |
 | `wendkeep sync-defs` | Copy `.brain/agents\|skills` into the project (`.codex/agents`, `.claude/skills`). |
 | `wendkeep validate-memory [path]` | Validate `.brain/CORE.md` (cap 25, 3 sections, no secrets/PII). |
@@ -104,17 +104,19 @@ No re‑copying, no snapshot to re‑sync — the package is the single source o
 
 ## Retroactive memory (`import`)
 
-Install wendkeep into an existing project and it only remembers sessions **from now on**. `wendkeep import` fixes that: it reads the project's past Claude Code transcripts (`~/.claude/projects/<slug>/*.jsonl`) and rebuilds each one as a full session note in its **real** date folder — frontmatter, one iteration block per turn, cost + subagent telemetry, derived decision/bug/learning notes, finalized closing. It is an offline replay of the live capture flow, so an imported note is indistinguishable from a captured one.
+Install wendkeep into an existing project and it only remembers sessions **from now on**. `wendkeep import` fixes that: it reads the project's past **Claude Code and Codex** transcripts and rebuilds each one as a full session note in its **real** date folder — frontmatter (tagged with the transcript's real provider), one iteration block per turn, cost + subagent telemetry, derived decision/bug/learning notes, finalized closing. It is an offline replay of the live capture flow, so an imported note is indistinguishable from a captured one.
 
 ```bash
-wendkeep import --vault .myproject-vault --dry-run   # preview what would be imported
+wendkeep import --vault .myproject-vault --dry-run   # preview what would be imported (both agents)
 wendkeep import --vault .myproject-vault             # write the notes
+wendkeep import --vault .myproject-vault --source codex   # just Codex
 ```
 
-- **Deduped** by `session_id` against the vault's `SESSION_REGISTRY` — only sessions not already present are imported, and it never overwrites an existing note. Re-running is a no-op.
-- **`--from <dir>`** points at the `.claude/projects/<slug>/` folder explicitly (use it if the auto-derived path misses). Also: `--since <date>`, `--limit <n>`, `--json`.
-- Once imported, `wendkeep cost` aggregates your entire history — retroactively.
-- v1 covers Claude Code; Codex import is a follow-up.
+- **Both agents by default** (`--source all`). Claude sessions come from `~/.claude/projects/<slug>/`; Codex rollouts from `~/.codex/sessions/**`, scoped to this project by the `cwd` recorded in each session (case- and separator-insensitive, subdirs included). Narrow with `--source claude` / `--source codex`.
+- Every note records its **`session_id`** and **`provider`** in frontmatter (live capture and import alike). Backfill older notes with `wendkeep import --stamp-ids` (fills the id from the registry; idempotent).
+- **Deduped** by `session_id` against the vault's `SESSION_REGISTRY` **and** existing notes' frontmatter — only sessions not already present are imported, and it never overwrites an existing note. Re-running is a no-op.
+- **`--from <dir>`** / **`--codex-from <dir>`** point at the transcript folders explicitly (use if the auto-derived path misses). Also: `--since <date>`, `--limit <n>`, `--json`.
+- Once imported, `wendkeep cost` aggregates your entire history — retroactively, across both agents.
 
 ## Change lifecycle — the a2 loop (spec‑driven, native)
 

package/hooks/import-sessions.mjs

@@ -4,7 +4,7 @@
 // dated folder, deduped by session_id against the vault's SESSION_REGISTRY. This is an offline
 // replay of the live capture flow — same skeleton, same iteration blocks, same cost/subagent
 // telemetry, same finalize — so an imported note is indistinguishable from a captured one.
-import { existsSync, readdirSync, writeFileSync } from 'fs';
+import { existsSync, readdirSync, writeFileSync, readFileSync, openSync, readSync, closeSync } from 'fs';
 import { basename, join } from 'path';
 import {
   parseTranscript,
@@ -19,6 +19,7 @@ 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 { getLocale } from './locale.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`.
@@ -48,6 +49,100 @@ export function discoverTranscripts(projectPath, fromDir) {
   return { dir, transcripts };
 }
 
+// --- Codex source -----------------------------------------------------------
+// Codex rollouts live in ~/.codex/sessions/YYYY/MM/DD/rollout-<ISO>-<uuid>.jsonl and are NOT
+// organized by project, so we scope them by the `cwd` recorded in each session_meta.
+
+export function defaultCodexSessionsDir() {
+  const home = homeDir();
+  return home ? join(home, '.codex', 'sessions') : '';
+}
+
+function normPath(p) {
+  return String(p || '').replace(/[\\/]+/g, '/').replace(/\/+$/, '').toLowerCase();
+}
+
+// A Codex session belongs to the project when it ran from the project root or any subdir.
+function cwdMatchesProject(cwd, projectPath) {
+  const c = normPath(cwd);
+  const proj = normPath(projectPath);
+  if (!c || !proj) return false;
+  return c === proj || c.startsWith(`${proj}/`);
+}
+
+// Recursively collect paths matching `re` (manual walk: readdir recursive lands in Node 20; floor is 18).
+function walkFiles(dir, re, out = []) {
+  let entries;
+  try { entries = readdirSync(dir, { withFileTypes: true }); } catch { return out; }
+  for (const e of entries) {
+    const p = join(dir, e.name);
+    if (e.isDirectory()) walkFiles(p, re, out);
+    else if (re.test(e.name)) out.push(p);
+  }
+  return out;
+}
+
+// Read only the leading bytes of a file (avoids slurping multi-MB transcripts / notes).
+function readPrefix(path, bytes = 4096) {
+  let fd;
+  try {
+    fd = openSync(path, 'r');
+    const buf = Buffer.alloc(bytes);
+    const n = readSync(fd, buf, 0, bytes, 0);
+    return buf.slice(0, n).toString('utf-8');
+  } catch {
+    return '';
+  } finally {
+    if (fd !== undefined) { try { closeSync(fd); } catch { /* already closed */ } }
+  }
+}
+
+// Pull the session_meta payload (id + cwd). session_meta is line 1 of a rollout.
+function readSessionMeta(path) {
+  for (const line of readPrefix(path, 16384).split('\n')) {
+    if (!line.trim()) continue;
+    let e;
+    try { e = JSON.parse(line); } catch { return null; } // partial/oversized first line -> skip
+    return e.type === 'session_meta' ? (e.payload || {}) : null;
+  }
+  return null;
+}
+
+// The `session_id` recorded in a note's frontmatter (empty when absent).
+function noteSessionId(path) {
+  const m = readPrefix(path, 2048).match(/^session_id:\s*["']?([^"'\r\n]+)["']?\s*$/m);
+  return m ? m[1].trim() : '';
+}
+
+// Every session_id the vault already has a record of: the SESSION_REGISTRY plus every session
+// note's frontmatter id. The registry is authoritative for wendkeep-native vaults, but scanning
+// notes too keeps import safe even if the registry was reset/lost — a session with a note on
+// disk is never re-imported.
+export function capturedSessionIds(vaultBase) {
+  const ids = new Set(Object.keys(readSessionRegistry(vaultBase).sessions || {}));
+  try {
+    const sessionsDir = join(vaultBase, getLocale(vaultBase).folders.sessions);
+    for (const path of walkFiles(sessionsDir, /\.md$/i)) {
+      const id = noteSessionId(path);
+      if (id) ids.add(id);
+    }
+  } catch { /* registry alone is enough */ }
+  return ids;
+}
+
+export function discoverCodexTranscripts(projectPath, fromDir) {
+  const dir = fromDir || defaultCodexSessionsDir();
+  if (!dir || !existsSync(dir)) return { dir, transcripts: [] };
+  const transcripts = [];
+  for (const path of walkFiles(dir, /\.jsonl$/i)) {
+    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 || '' });
+  }
+  return { dir, transcripts };
+}
+
 // Session objective for the note title/frontmatter: first real user prompt, one line.
 function deriveSummary(tx) {
   for (const turn of tx.turns || []) {
@@ -66,19 +161,22 @@ function toDate(ts, fallback) {
 
 // Replay one transcript into a fresh, finalized note. Returns {sessionId, relPath, turns} or
 // null when the transcript has no memorializable turns. Assumes the caller already deduped.
-export function importSession(vaultBase, txPath, preParsed) {
+// opts: { tx (pre-parsed), sessionId (registry key — pass the discovered id so registration
+// matches the dedup key exactly; falls back to the transcript's own id) }.
+export function importSession(vaultBase, txPath, opts = {}) {
+  const { tx: preParsed, sessionId: sessionIdOverride } = opts;
   const tx = preParsed || parseTranscript(txPath);
   const turns = tx.turns || [];
   if (!turns.length) return null;
 
-  const sessionId = tx.sessionId || basename(String(txPath), '.jsonl');
+  const sessionId = sessionIdOverride || tx.sessionId || basename(String(txPath), '.jsonl');
   const startDate = toDate(turns[0].timestamp, new Date());
   const endDate = toDate(turns.at(-1).timestamp, startDate);
   const summary = deriveSummary(tx);
 
-  // Skeleton in the real dated folder.
+  // Skeleton in the real dated folder, tagged with the transcript's own provider + session id.
   const { absPath, relPath } = allocateSessionPath(vaultBase, startDate, summary);
-  writeFileSync(absPath, buildSessionContent({ relPath, now: startDate, summary }), 'utf-8');
+  writeFileSync(absPath, buildSessionContent({ relPath, now: startDate, summary, provider: tx.provider, sessionId }), 'utf-8');
 
   // One iteration block per turn (insertIteration dedups by turn marker -> re-import safe).
   for (const turn of turns) {
@@ -115,14 +213,57 @@ export function importSession(vaultBase, txPath, preParsed) {
   return { sessionId, relPath, turns: turns.length };
 }
 
-// Import every not-yet-captured transcript. Deduped by session_id against the registry.
-// Options: { projectPath, from, since (ISO/date), limit, dryRun }.
+// 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) {
+  const q = `"${String(sessionId).replace(/"/g, '\\"')}"`;
+  if (/^session_id:\s*$/m.test(content)) return content.replace(/^session_id:\s*$/m, `session_id: ${q}`);
+  if (/^session_id:\s*\S/m.test(content)) return content; // already has a value
+  if (/^provider:.*$/m.test(content)) return content.replace(/^(provider:.*)$/m, `$1\nsession_id: ${q}`);
+  return content.replace(/^---\s*$/m, `---\nsession_id: ${q}`);
+}
+
+// Backfill `session_id` into existing session notes from the SESSION_REGISTRY (session_file -> id).
+// For notes captured/imported before the field existed. Idempotent; only touches notes missing it.
+export function stampSessionIds(vaultBase) {
+  const reg = readSessionRegistry(vaultBase).sessions || {};
+  const report = { total: Object.keys(reg).length, stamped: 0, alreadyOk: 0, missingFile: 0 };
+  for (const [sessionId, entry] of Object.entries(reg)) {
+    if (!entry?.session_file) continue;
+    const abs = join(vaultBase, entry.session_file);
+    if (!existsSync(abs)) { report.missingFile++; continue; }
+    let content;
+    try { content = readFileSync(abs, 'utf-8'); } catch { report.missingFile++; continue; }
+    const next = injectSessionIdFrontmatter(content, sessionId);
+    if (next !== content) { writeFileSync(abs, next, 'utf-8'); report.stamped++; }
+    else { report.alreadyOk++; }
+  }
+  return report;
+}
+
+// Import every not-yet-captured transcript from the requested source(s). Deduped by session_id
+// against the registry. Options: { projectPath, source ('all'|'claude'|'codex'), from, codexFrom,
+// since (ISO/date), limit, dryRun }. importSession is provider-agnostic, so both sources share
+// the same dedup + import loop.
 export function runImport(vaultBase, opts = {}) {
-  const { projectPath = process.cwd(), from = '', since = '', limit = 0, dryRun = false } = opts;
-  const { dir, transcripts } = discoverTranscripts(projectPath, from);
-  const captured = new Set(Object.keys(readSessionRegistry(vaultBase).sessions || {}));
+  const { projectPath = process.cwd(), source = 'all', from = '', codexFrom = '', since = '', limit = 0, dryRun = false } = opts;
+  const src = String(source).toLowerCase();
+  const transcripts = [];
+  let claudeDir = '';
+  let codexDir = '';
+  if (src === 'all' || src === 'claude') {
+    const d = discoverTranscripts(projectPath, from);
+    claudeDir = d.dir;
+    transcripts.push(...d.transcripts);
+  }
+  if (src === 'all' || src === 'codex') {
+    const d = discoverCodexTranscripts(projectPath, codexFrom);
+    codexDir = d.dir;
+    transcripts.push(...d.transcripts);
+  }
+  const captured = capturedSessionIds(vaultBase);
   const sinceMs = since ? Date.parse(since) : 0;
-  const report = { dir, scanned: transcripts.length, imported: 0, skipped: 0, errors: [], sessions: [] };
+  const report = { source: src, claudeDir, codexDir, scanned: transcripts.length, imported: 0, skipped: 0, errors: [], sessions: [] };
 
   let done = 0;
   for (const t of transcripts) {
@@ -153,7 +294,7 @@ export function runImport(vaultBase, opts = {}) {
     }
 
     try {
-      const r = importSession(vaultBase, t.path, tx);
+      const r = importSession(vaultBase, t.path, { tx, sessionId: t.sessionId });
       if (r) { report.sessions.push(r); report.imported++; done++; }
       else { report.skipped++; }
     } catch (error) {

package/hooks/session-start.mjs

@@ -31,12 +31,14 @@ import {
   yamlQuote,
 } from './obsidian-common.mjs';
 
-export function buildSessionContent({ relPath, now, summary = 'session' }) {
+export function buildSessionContent({ relPath, now, summary = 'session', provider: providerId, sessionId = '' }) {
   const date = formatDate(now);
   const startedAt = formatLocalIso(now);
   const titleTime = formatTime(now).slice(0, 5);
   const objective = summary === 'session' ? 'Preencher durante a sessão.' : summary;
-  const provider = providerMeta();
+  // Import passes the transcript's provider so a Codex note is tagged codex (not the
+  // ambient default); undefined falls back to providerMeta's own detection.
+  const provider = providerMeta(providerId);
 
   return `---
 type: session
@@ -44,6 +46,7 @@ date: ${date}
 started_at: ${startedAt}
 ended_at:
 provider: ${provider.id}
+session_id: ${sessionId ? yamlQuote(sessionId) : ''}
 status: active
 summary: ${yamlQuote(summary)}
 cssclasses:
@@ -200,7 +203,7 @@ function main() {
       const knownAbs = join(vaultBase, known.session_file);
       if (!existsSync(knownAbs)) {
         ensureDir(join(vaultBase, known.session_file.split('/').slice(0, -1).join('/')));
-        writeFileSync(knownAbs, buildSessionContent({ relPath: known.session_file, now, summary: sessionSummaryFromInput(input) }), 'utf-8');
+        writeFileSync(knownAbs, buildSessionContent({ relPath: known.session_file, now, summary: sessionSummaryFromInput(input), sessionId }), 'utf-8');
       }
       const startedAt = known.started_at || control.started_at || formatLocalIso(now);
       writeControl(vaultBase, {
@@ -242,7 +245,7 @@ function main() {
       const matchAbs = join(vaultBase, match.session_file);
       if (!existsSync(matchAbs)) {
         ensureDir(join(vaultBase, match.session_file.split('/').slice(0, -1).join('/')));
-        writeFileSync(matchAbs, buildSessionContent({ relPath: match.session_file, now, summary: sessionSummaryFromInput(input) }), 'utf-8');
+        writeFileSync(matchAbs, buildSessionContent({ relPath: match.session_file, now, summary: sessionSummaryFromInput(input), sessionId: sessionId || match.sessionId }), 'utf-8');
       }
       const startedAt = match.started_at || control.started_at || formatLocalIso(now);
       writeControl(vaultBase, {
@@ -274,7 +277,7 @@ function main() {
   const summary = sessionSummaryFromInput(input);
   const { absPath, relPath } = allocateSessionPath(vaultBase, now, summary);
   const startedAt = formatLocalIso(now);
-  writeFileSync(absPath, buildSessionContent({ relPath, now, summary }), 'utf-8');
+  writeFileSync(absPath, buildSessionContent({ relPath, now, summary, sessionId }), 'utf-8');
   writeControl(vaultBase, {
     status: 'active',
     session_file: relPath,

package/hooks/session-stop.mjs

@@ -199,6 +199,7 @@ function toolArgumentText(value) {
 
 export function parseCodexTranscript(transcriptPath) {
   const result = {
+    provider: 'codex',
     sessionId: '',
     model: '',
     latestTurnId: '',
@@ -380,6 +381,7 @@ function claudeUserText(content) {
 // Diferente do Codex (sem `payload`), por isso precisa de parser próprio.
 export function parseClaudeTranscript(transcriptPath) {
   const result = {
+    provider: 'claude',
     sessionId: '',
     model: '',
     latestTurnId: '',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wendkeep",
-  "version": "0.16.0",
+  "version": "0.18.0",
   "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, defaultClaudeProjectsDir } from '../hooks/import-sessions.mjs';
+import { runImport, stampSessionIds } from '../hooks/import-sessions.mjs';
 
 function opt(argv, name) {
   const i = argv.indexOf(name);
@@ -18,27 +18,34 @@ 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: backfill session_id into existing notes from the registry, then stop.
+  if (argv.includes('--stamp-ids')) {
+    const r = stampSessionIds(vaultBase);
+    if (argv.includes('--json')) { process.stdout.write(`${JSON.stringify(r, null, 2)}\n`); process.exit(0); }
+    process.stdout.write(`session_id carimbado em ${r.stamped} nota(s) · ${r.alreadyOk} já ok · ${r.missingFile} sem arquivo (de ${r.total} no registry)\n`);
+    process.exit(0);
+  }
+
   const projectRaw = opt(argv, '--project') || process.cwd();
   const projectPath = isAbsolute(projectRaw) ? projectRaw : resolve(process.cwd(), projectRaw);
+  const source = (opt(argv, '--source') || 'all').toLowerCase();
+  if (!['all', 'claude', 'codex'].includes(source)) {
+    process.stderr.write(`wendkeep import: --source must be all | claude | codex (got "${source}").\n`);
+    process.exit(2);
+  }
   const from = opt(argv, '--from') || '';
+  const codexFrom = opt(argv, '--codex-from') || '';
   const since = opt(argv, '--since') || '';
   const limit = Number(opt(argv, '--limit')) || 0;
   const dryRun = argv.includes('--dry-run');
 
-  const sourceDir = from || defaultClaudeProjectsDir(projectPath);
-  if (!from && (!sourceDir || !existsSync(sourceDir))) {
-    process.stderr.write(`wendkeep import: no Claude transcripts for this project.\n`);
-    process.stderr.write(`  Looked in: ${sourceDir || '(home not resolved)'}\n`);
-    process.stderr.write(`  Pass --from <dir> pointing at .claude/projects/<slug>/ explicitly.\n`);
-    process.exit(2);
-  }
-
-  const report = runImport(vaultBase, { projectPath, from, since, limit, dryRun });
+  const report = runImport(vaultBase, { projectPath, source, from, codexFrom, since, limit, dryRun });
 
   if (argv.includes('--json')) { process.stdout.write(`${JSON.stringify(report, null, 2)}\n`); process.exit(0); }
 
   const verb = dryRun ? 'importaria' : 'importadas';
-  process.stdout.write(`Fonte: ${report.dir}\n`);
+  if (report.claudeDir) process.stdout.write(`Claude: ${report.claudeDir}\n`);
+  if (report.codexDir) process.stdout.write(`Codex:  ${report.codexDir}\n`);
   process.stdout.write(`${report.scanned} transcript(s) · ${report.imported} ${verb} · ${report.skipped} já no vault\n`);
   for (const s of report.sessions) {
     const tag = s.dryRun ? '(dry-run)' : '→';