renor-engine 0.0.0-stage → 1.0.0

package/dist/context/rowStore.js

@@ -0,0 +1,238 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProvenanceError = void 0;
+exports.normDedupeValue = normDedupeValue;
+exports.matchForm = matchForm;
+exports.splitWords = splitWords;
+exports.dedupeKeyFor = dedupeKeyFor;
+exports.insertStructuredRows = insertStructuredRows;
+exports.deleteStructuredRowsForSource = deleteStructuredRowsForSource;
+exports.deleteStructuredRowsForSourceKind = deleteStructuredRowsForSourceKind;
+exports.readCurrentRowsForNotes = readCurrentRowsForNotes;
+const orchestrator_1 = require("../retrieval/orchestrator");
+class ProvenanceError extends Error {
+}
+exports.ProvenanceError = ProvenanceError;
+/** NFKD → fold Latin diacritics → keep letters/numbers/marks from every script → lowercase → collapse.
+ *
+ * Letters and numbers are kept from EVERY script (`\p{L}`/`\p{N}`), never an
+ * ASCII range. The previous `[^\x20-\x7E]` + `[^a-z0-9]` pair deleted every
+ * non-Latin character, so two distinct memories written in Chinese, Japanese,
+ * Cyrillic, Greek, Arabic, Hebrew or Devanagari both normalized to `''` and
+ * shared one identity — and `decision-model` then called one `identical` to the
+ * other, folding the candidate into the existing row's confirm_count instead of
+ * storing it. Silent data loss.
+ *
+ * Combining marks are folded ONLY after a Latin base letter, which is what keeps
+ * the existing accent folding (`Café` → `cafe`) without destroying the marks
+ * that ARE letters in other scripts. A blanket `\p{M}` strip looks equivalent on
+ * Latin but merges meaning-changing pairs in scripts this bug report names:
+ * `が`/`か`, `ぱ`/`は`, `की`/`क`, `मिल`/`मील`, `น้ำ`/`นำ` (measured; pinned by test).
+ * To go back to the blanket strip, delete only the lookbehind (making the two
+ * mark clauses `\p{M}` in both places).
+ *
+ * `\p{L}` is `a-zA-Z` and `\p{N}` is `0-9` within ASCII, so ASCII identities are
+ * unchanged. `\p{C}` (control, format, private-use, unassigned) is REMOVED rather
+ * than treated as a separator, matching what the old `[^\x20-\x7E]` filter did to
+ * those characters — so every ASCII input stays byte-identical, including one
+ * carrying a control character. That preserves one pre-existing quirk: a control
+ * character between two word characters glues them (`'a\u0000b'` → `ab`);
+ * separating instead would move ASCII identities, so it is left out of scope.
+ *
+ * Values with no letters or numbers (punctuation, symbols, emoji) still normalize
+ * to `''`, exactly as before. Dataset-free. */
+function normDedupeValue(value) {
+    return value
+        .normalize('NFKD')
+        .replace(/(?<=\p{Script=Latin})\p{M}+/gu, '')
+        .toLowerCase()
+        .replace(/\p{C}+/gu, '')
+        .replace(/[^\p{L}\p{N}\p{M}]+/gu, ' ')
+        .trim();
+}
+/** The read side's word separator: the SAME class `normDedupeValue` uses above, so a query
+ *  is cut into words exactly as the text it must match is. `\p{L}`/`\p{N}`/`\p{M}` cover
+ *  every script; both are exactly `a-z`/`0-9`/nothing within ASCII, so an ASCII query is
+ *  cut into byte-identical words.
+ *
+ *  Splitting on the ASCII range instead (`[^a-z0-9]`) deletes every non-ASCII letter, and a
+ *  word that is *entirely* non-ASCII is deleted whole rather than shortened: `não` became
+ *  `n`+`o`, `東京` became nothing, `東京都` became nothing. A read then lost the identity of
+ *  the very facts it was written to find — measured on this repo's read paths in
+ *  `tests/context/readSideUnicodeTokens.test.ts`: a `東京都` query scored every row 0, so
+ *  `大阪に通っている` (newer, irrelevant) outranked `東京都に住んでいる`, and the query
+ *  scoped to no row at all, returning the whole table.
+ *
+ *  `numeric` additionally keeps `.` and `%` inside a word, so a measurement stays one word
+ *  ("3.5%", "42 Wh"). Both variants were the pre-existing ASCII classes plus `\p{L}\p{N}\p{M}`
+ *  widened from `a-z0-9`, so no ASCII word changes.
+ *
+ *  Deliberately NOT NFKD-folded, unlike `normDedupeValue`: the read side matches its terms
+ *  with `includes()` against the RAW stored text (`rowSearchText` + `indexOf`), so folding
+ *  here would stop a term from matching the very row it names. Marks are kept as word
+ *  characters for the same reason the write side keeps them for non-Latin scripts. */
+const WORD_SEPARATOR = /[^\p{L}\p{N}\p{M}]+/u;
+const WORD_SEPARATOR_NUMERIC = /[^\p{L}\p{N}\p{M}.%]+/u;
+/** The one form the read side matches on: NFC, then lowercased. Applied to BOTH the query
+ *  and the text it is matched against, so a query matches a stored fact however either was
+ *  spelled. Stored payloads are never normalized (they are written as given), and NFC is
+ *  *not* the same string as NFD — macOS-authored text, pasted filenames and Obsidian on Mac
+ *  all produce NFD — so an NFC query term would otherwise miss an NFD fact (`café` vs
+ *  `café`) that a raw substring test cannot bridge. ASCII is NFC-stable, so this is
+ *  identity on every ASCII input. NOT NFKD and NOT accent-folded: the match is a raw
+ *  `includes()`, so folding a term would stop it matching the very row it names, which is
+ *  also why the write side's `normDedupeValue` folding cannot be reused here. */
+function matchForm(text) {
+    return (text ?? '').normalize('NFC').toLowerCase();
+}
+/** Lowercased NFC words of `text` in order, repeats included — callers de-duplicate. A query
+ *  and the stored text it is matched against are both put in `matchForm`, so the cut cannot
+ *  differ by side. */
+function splitWords(text, numeric = false) {
+    return matchForm(text).split(numeric ? WORD_SEPARATOR_NUMERIC : WORD_SEPARATOR);
+}
+/** dedupe_key per ADR §4: fact (value, object), event (when, event), pref (statement). */
+function dedupeKeyFor(row) {
+    switch (row.rowKind) {
+        case 'fact': {
+            const p = row.payload;
+            return `fact|${normDedupeValue(p.value)}|${normDedupeValue(p.object)}`;
+        }
+        case 'event': {
+            const p = row.payload;
+            return `event|${normDedupeValue(p.when)}|${normDedupeValue(p.event)}`;
+        }
+        case 'preference': {
+            const p = row.payload;
+            return `pref|${normDedupeValue(p.statement)}`;
+        }
+    }
+}
+function assertProvenance(row) {
+    if (!row.sourcePath || !row.sourcePath.trim()) {
+        throw new ProvenanceError(`structured row (${row.rowKind}) rejected: missing source_path`);
+    }
+    if (!Number.isInteger(row.sourceChunkId) || row.sourceChunkId <= 0) {
+        throw new ProvenanceError(`structured row (${row.rowKind}) from ${row.sourcePath} rejected: missing source_chunk_id`);
+    }
+}
+function parsePayload(rowKind, raw) {
+    return JSON.parse(raw);
+}
+/**
+ * Insert rows with identity-keyed supersession (ADR-0003 §4.1). A new row
+ * supersedes a current row only when they share (row_kind, scope, dedupe_key)
+ * AND both content dates are known AND the new source is not older. When
+ * either date is NULL (unknown), supersession never fires: both rows stay
+ * current and the composer orders them deterministically.
+ *
+ * Same-identity double-insert from the SAME source cannot occur: migration
+ * v11's partial UNIQUE index (current rows only) closes the check-then-act
+ * race across `await model.decide`, and a lost race is re-checked here and
+ * skipped (the winning writer's row already covers the identity) instead of
+ * double-inserting. Cross-note coexistence (different source_path) is
+ * preserved by the index's source_path column.
+ */
+function insertStructuredRows(db, rows, opts = {}) {
+    const insert = db.prepare(`
+    INSERT INTO structured_rows
+      (row_kind, source_path, source_hash, source_chunk_id, scope, extraction_version,
+       valid_from, valid_to, payload_json, dedupe_key, created_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?, NULL, ?, ?, ?)
+  `);
+    // A content date is only as late as its file's write time. Rows stored before this bound existed are bounded the same
+    // way wherever they are read, including here, so a stale future date cannot outrank a normal later update.
+    const findCurrent = db.prepare(`
+    SELECT r.id, r.valid_from, n.modified_at
+    FROM structured_rows r LEFT JOIN notes n ON n.path = r.source_path
+    WHERE r.row_kind = ? AND r.scope = ? AND r.dedupe_key = ? AND r.valid_to IS NULL
+  `);
+    const writeTime = db.prepare('SELECT modified_at FROM notes WHERE path = ?');
+    const supersede = db.prepare('UPDATE structured_rows SET valid_to = ? WHERE id = ?');
+    db.transaction(() => {
+        for (const row of rows) {
+            assertProvenance(row);
+            const validFrom = (0, orchestrator_1.boundContentDate)(row.validFrom, writeTime.get(row.sourcePath)?.modified_at);
+            const dedupeKey = dedupeKeyFor(row);
+            const scope = row.scope ?? 'global';
+            const now = new Date().toISOString();
+            if (validFrom !== null && !opts.skipSupersession) {
+                for (const existing of findCurrent.all(row.rowKind, scope, dedupeKey)) {
+                    // Supersede only on identity collision with known dates on both
+                    // sides; the newer (or same-date re-extraction) source wins.
+                    const existingFrom = (0, orchestrator_1.boundContentDate)(existing.valid_from, existing.modified_at);
+                    if (existingFrom !== null && validFrom >= existingFrom) {
+                        supersede.run(validFrom, existing.id);
+                    }
+                }
+            }
+            try {
+                insert.run(row.rowKind, row.sourcePath, row.sourceHash, row.sourceChunkId, scope, row.extractionVersion, validFrom, JSON.stringify(row.payload), dedupeKey, now);
+            }
+            catch (err) {
+                const code = err?.code ?? '';
+                const message = err instanceof Error ? err.message : String(err);
+                if (code === 'SQLITE_CONSTRAINT_UNIQUE' || /UNIQUE constraint failed/.test(message)) {
+                    // Lost a same-identity insert race against a concurrent writer for
+                    // this source (migration v11 partial UNIQUE index). Re-check: a
+                    // current row already covers the identity from this source — skip
+                    // instead of double-inserting; anything else is a real error.
+                    const dupe = db
+                        .prepare(`SELECT id FROM structured_rows
+               WHERE row_kind = ? AND scope = ? AND dedupe_key = ? AND source_path = ? AND valid_to IS NULL LIMIT 1`)
+                        .get(row.rowKind, scope, dedupeKey, row.sourcePath);
+                    if (dupe)
+                        continue;
+                }
+                throw err;
+            }
+        }
+    })();
+}
+/** Edit path (ADR-0003 §4.2): re-index of a note deletes its rows; re-extraction repopulates. */
+function deleteStructuredRowsForSource(db, sourcePath) {
+    db.prepare('DELETE FROM structured_rows WHERE source_path = ?').run(sourcePath);
+}
+/**
+ * Same edit path, scoped to one lane.
+ *
+ * The whole-source delete removes every row kind for a note. With more than
+ * one lane armed, the second lane's cleanup deleted the first lane's fresh
+ * rows and the third deleted both. The cache key is per lane
+ * (source_hash + extraction_version), so stale-row cleanup is too.
+ */
+function deleteStructuredRowsForSourceKind(db, sourcePath, rowKind) {
+    db.prepare('DELETE FROM structured_rows WHERE source_path = ? AND row_kind = ?')
+        .run(sourcePath, rowKind);
+}
+/**
+ * Current-only read joined to the live notes table: a row whose source_path no
+ * longer resolves to a live note is never returned (provenance guard), even if
+ * a connection without the FK pragma leaked orphans into the table.
+ */
+function readCurrentRowsForNotes(db, notePaths) {
+    if (notePaths.length === 0)
+        return [];
+    const placeholders = notePaths.map(() => '?').join(', ');
+    const rows = db.prepare(`SELECT r.id, r.row_kind, r.source_path, r.source_hash, r.source_chunk_id,
+            r.scope, r.extraction_version, r.valid_from, r.valid_to, r.payload_json, r.dedupe_key,
+            r.confirm_count, n.modified_at
+     FROM structured_rows r
+     JOIN notes n ON n.path = r.source_path
+     WHERE r.valid_to IS NULL AND r.source_path IN (${placeholders})
+     ORDER BY r.id`).all(...notePaths);
+    return rows.map((r) => ({
+        id: r.id,
+        rowKind: r.row_kind,
+        sourcePath: r.source_path,
+        sourceChunkId: r.source_chunk_id,
+        sourceHash: r.source_hash,
+        scope: r.scope,
+        extractionVersion: r.extraction_version,
+        validFrom: (0, orchestrator_1.boundContentDate)(r.valid_from ?? null, r.modified_at),
+        validTo: r.valid_to ?? null,
+        payload: parsePayload(r.row_kind, r.payload_json),
+        dedupeKey: r.dedupe_key,
+        confirmCount: r.confirm_count ?? 1,
+    }));
+}

package/dist/conversation/formatter.js

@@ -0,0 +1,81 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildFilename = buildFilename;
+exports.formatConversation = formatConversation;
+const crypto_1 = __importDefault(require("crypto"));
+// Возвращает YYYY-MM-DD из ISO-строки
+function isoToDate(iso) {
+    return iso.substring(0, 10);
+}
+// Возвращает HH:mm из ISO-строки
+function isoToTime(iso) {
+    return iso.substring(11, 16);
+}
+// A file name is at most 255 bytes; the date prefix and ".md" take about 22 of them, so the title gets this many UTF-8 bytes.
+const MAX_TITLE_BYTES = 120;
+// Убирает символы, недопустимые в именах файлов, и управляющие символы (NUL ломает путь); длинное название обрезается
+// и получает короткий хеш полного названия, чтобы разные разговоры не совпали по имени файла.
+function sanitizeTitle(title) {
+    const clean = title.replace(/[/\\:*?"<>|\x00-\x1f\x7f]/g, "-").trim();
+    if (Buffer.byteLength(clean, "utf8") <= MAX_TITLE_BYTES)
+        return clean;
+    let kept = "";
+    for (const ch of clean) {
+        if (Buffer.byteLength(kept + ch, "utf8") > MAX_TITLE_BYTES)
+            break;
+        kept += ch;
+    }
+    const digest = crypto_1.default.createHash("sha256").update(title).digest("hex").slice(0, 8);
+    return `${kept.trimEnd()}-${digest}`;
+}
+function buildFilename(title, isoTime) {
+    const date = isoToDate(isoTime);
+    const time = isoToTime(isoTime).replace(":", "-");
+    return `${date} ${time} - ${sanitizeTitle(title)}.md`;
+}
+function formatToolCall(tc) {
+    if (tc.kind === "edit") {
+        const diffLines = [
+            ...tc.oldString.split("\n").map((l) => `> - ${l}`),
+            ...tc.newString.split("\n").map((l) => `> + ${l}`),
+        ].join("\n");
+        return `> **Edit** \`${tc.filePath}\`\n> \`\`\`diff\n${diffLines}\n> \`\`\``;
+    }
+    if (tc.kind === "write") {
+        return `> **Write** \`${tc.filePath}\``;
+    }
+    return `> **Bash** \`${tc.command}\``;
+}
+function formatTurn(turn) {
+    const parts = [];
+    if (turn.text) {
+        const label = turn.role === "user" ? "User" : "Assistant";
+        parts.push(`**${label}:** ${turn.text}`);
+    }
+    for (const tc of turn.toolCalls) {
+        parts.push(formatToolCall(tc));
+    }
+    return parts.join("\n\n");
+}
+function formatConversation(conv) {
+    const date = isoToDate(conv.timeStart);
+    const timeStart = isoToTime(conv.timeStart);
+    // Убираем переносы строк, чтобы не сломать YAML-фронтматтер
+    const safeSessionId = conv.sessionId.replace(/[\r\n]/g, " ");
+    const safeProject = conv.project.replace(/[\r\n]/g, " ");
+    const frontmatter = [
+        "---",
+        "kind: conversation",
+        `date: ${date}`,
+        `time_start: ${timeStart}`,
+        `session_id: ${safeSessionId}`,
+        `project: ${safeProject}`,
+        `title: ${JSON.stringify(conv.title)}`,
+        "---",
+    ].join("\n");
+    const body = conv.turns.map(formatTurn).filter(Boolean).join("\n\n");
+    return `${frontmatter}\n\n${body}\n`;
+}

package/dist/conversation/parser.js

@@ -0,0 +1,189 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encodeProjectPath = encodeProjectPath;
+exports.resolveJSONLPath = resolveJSONLPath;
+exports.parseConversation = parseConversation;
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+/**
+ * Кодирует путь проекта в формат имени директории Claude Code:
+ * слэши заменяются на дефисы (как в ~/.claude/projects/).
+ */
+function encodeProjectPath(cwd) {
+    return cwd.replace(/\//g, "-");
+}
+/**
+ * Возвращает абсолютный путь к JSONL-файлу сессии в директории проектов Claude Code.
+ */
+function resolveJSONLPath(sessionId, cwd) {
+    const encoded = encodeProjectPath(cwd);
+    const projects = path_1.default.join(os_1.default.homedir(), ".claude", "projects");
+    const file = path_1.default.join(projects, encoded, `${sessionId}.jsonl`);
+    // The session id comes from the hook payload and names a file: a separator or a `..` that leaves the projects
+    // directory is refused, never read (a transcript of another file would otherwise be written to the vault).
+    if (/[\\/]/.test(sessionId) || !file.startsWith(projects + path_1.default.sep)) {
+        throw new Error("session_id must name a file in the Claude Code projects directory");
+    }
+    return file;
+}
+/**
+ * Определяет, является ли сообщение пользователя внутренним (системным).
+ * Внутренние сообщения не включаются в итоговый разговор:
+ * - только tool_result блоки (ответ инструмента, не пользователь)
+ * - сообщения с тегами CLI (local-command, command-name)
+ */
+function isInternalUserMessage(content) {
+    if (content.length === 0)
+        return true;
+    // Только tool_result блоки — ответ инструмента, не настоящий пользователь
+    if (content.every((b) => b.type === "tool_result"))
+        return true;
+    // Внутренние теги Claude Code CLI
+    const firstText = content.find((b) => b.type === "text")?.text ?? "";
+    if (firstText.startsWith("<local-command") ||
+        firstText.startsWith("<command-name>"))
+        return true;
+    return false;
+}
+/**
+ * Ждёт появления записи ai-title в JSONL-файле с повторными попытками.
+ * Claude Code генерирует заголовок асинхронно после завершения сессии,
+ * поэтому Stop hook может сработать раньше, чем заголовок записан.
+ *
+ * @param jsonlPath - путь к .jsonl файлу
+ * @param retries - максимальное количество попыток (каждая с задержкой 2с)
+ */
+async function waitForAiTitle(jsonlPath, retries = 8, intervalMs = 2000) {
+    for (let i = 0; i < retries; i++) {
+        await new Promise((resolve) => setTimeout(resolve, intervalMs));
+        let raw;
+        try {
+            raw = await promises_1.default.readFile(jsonlPath, "utf8");
+        }
+        catch {
+            return null;
+        }
+        for (const line of raw.split("\n")) {
+            try {
+                const entry = JSON.parse(line);
+                if (entry.type === "ai-title" && entry.aiTitle) {
+                    return entry.aiTitle;
+                }
+            }
+            catch {
+                continue;
+            }
+        }
+    }
+    return null;
+}
+/**
+ * Парсит JSONL-файл сессии Claude Code и возвращает структурированный разговор.
+ *
+ * @param jsonlPath - путь к .jsonl файлу сессии
+ * @param sessionId - идентификатор сессии (используется как fallback заголовок)
+ * @param cwd - рабочая директория проекта
+ */
+async function parseConversation(jsonlPath, sessionId, cwd, options = {}) {
+    const raw = await promises_1.default.readFile(jsonlPath, "utf8");
+    const lines = raw.split("\n").filter((l) => l.trim());
+    let title = sessionId;
+    let timeStart = new Date().toISOString();
+    let timeStartFound = false;
+    const turns = [];
+    for (const line of lines) {
+        let entry;
+        try {
+            entry = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        // Извлекаем заголовок сессии из специальной записи ai-title
+        if (entry.type === "ai-title" && entry.aiTitle) {
+            title = entry.aiTitle;
+            continue;
+        }
+        // Время начала = первый dequeue из очереди операций
+        if (!timeStartFound &&
+            entry.type === "queue-operation" &&
+            entry.operation === "dequeue") {
+            timeStart = entry.timestamp;
+            timeStartFound = true;
+            continue;
+        }
+        // Пропускаем мета-сообщения (системные уведомления Claude Code)
+        // и сайдчейн-записи (внутренние подразговоры оркестратора)
+        if (entry.isMeta || entry.isSidechain)
+            continue;
+        if (entry.type === "user" && entry.message?.role === "user") {
+            // content может быть строкой (короткие сессии) или массивом блоков
+            const rawContent = entry.message.content;
+            const content = Array.isArray(rawContent)
+                ? rawContent
+                : typeof rawContent === "string" && rawContent.trim()
+                    ? [{ type: "text", text: rawContent }]
+                    : [];
+            if (isInternalUserMessage(content))
+                continue;
+            const text = content
+                .filter((b) => b.type === "text")
+                .map((b) => b.text)
+                .join("\n")
+                .trim();
+            if (!text)
+                continue;
+            turns.push({ role: "user", text, toolCalls: [] });
+            continue;
+        }
+        if (entry.type === "assistant" && entry.message?.role === "assistant") {
+            const rawContent = entry.message.content;
+            const content = Array.isArray(rawContent)
+                ? rawContent
+                : typeof rawContent === "string" && rawContent.trim()
+                    ? [{ type: "text", text: rawContent }]
+                    : [];
+            const text = content
+                .filter((b) => b.type === "text")
+                .map((b) => b.text)
+                .join("\n")
+                .trim();
+            const toolCalls = [];
+            for (const block of content) {
+                if (block.type !== "tool_use")
+                    continue;
+                if (block.name === "Edit" && block.input?.file_path) {
+                    toolCalls.push({
+                        kind: "edit",
+                        filePath: block.input.file_path,
+                        oldString: block.input.old_string ?? "",
+                        newString: block.input.new_string ?? "",
+                    });
+                }
+                else if (block.name === "Write" && block.input?.file_path) {
+                    toolCalls.push({ kind: "write", filePath: block.input.file_path });
+                }
+                else if (block.name === "Bash" && block.input?.command) {
+                    toolCalls.push({ kind: "bash", command: block.input.command });
+                }
+            }
+            if (!text && toolCalls.length === 0)
+                continue;
+            turns.push({ role: "assistant", text, toolCalls });
+        }
+    }
+    // Если заголовок не найден — ждём: Claude Code записывает ai-title асинхронно.
+    // Ждём только если в JSONL есть queue-operation (признак полноценной сессии).
+    // Короткие сессии без queue-operation ai-title не получают.
+    const { maxRetries = 8, retryIntervalMs = 2000 } = options;
+    if (title === sessionId && timeStartFound && maxRetries > 0) {
+        const aiTitle = await waitForAiTitle(jsonlPath, maxRetries, retryIntervalMs);
+        if (aiTitle)
+            title = aiTitle;
+    }
+    return { sessionId, title, timeStart, project: cwd, turns };
+}

package/dist/conversation/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/conversation/writer.js

@@ -0,0 +1,42 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeConversation = writeConversation;
+const path_1 = __importDefault(require("path"));
+const formatter_1 = require("./formatter");
+const secretGuard_1 = require("../extraction/secretGuard");
+const confinedWrite_1 = require("../memory/confinedWrite");
+/**
+ * Записывает разговор в файл markdown в хранилище.
+ * @param vaultPath - корневой путь хранилища
+ * @param conversationsDir - относительный путь к папке разговоров (например, "Claude Code/Conversations")
+ * @param conv - распарсенный разговор
+ * @returns абсолютный путь к созданному файлу
+ * @throws Error если обнаружена попытка обхода пути
+ */
+async function writeConversation(vaultPath, conversationsDir, conv) {
+    const filename = (0, formatter_1.buildFilename)(conv.title, conv.timeStart);
+    const dir = path_1.default.join(vaultPath, conversationsDir);
+    // Защита от path traversal через имя файла
+    const filePath = path_1.default.join(dir, filename);
+    const resolvedPath = path_1.default.resolve(filePath);
+    const resolvedBase = path_1.default.resolve(dir);
+    if (!resolvedPath.startsWith(resolvedBase + path_1.default.sep) &&
+        resolvedPath !== resolvedBase) {
+        throw new Error("Path traversal detected in conversation filename");
+    }
+    // RENOR_SECRET_GUARD (default ON): a transcript that looks like it holds a secret is not written, and the
+    // directory is not created. The caller (the log-conversation hook) reports the refusal and exits cleanly.
+    if ((0, secretGuard_1.secretGuardEnabled)()) {
+        await (0, secretGuard_1.assertStorable)([
+            { field: "conversation", text: (0, formatter_1.formatConversation)(conv) },
+            { field: "conversation file name", text: filename },
+        ]);
+    }
+    const content = (0, formatter_1.formatConversation)(conv);
+    // A link, a hard link or a FIFO planted in the vault is refused, never followed (memory/confinedWrite.ts).
+    await (0, confinedWrite_1.writeConfined)(vaultPath, path_1.default.relative(path_1.default.resolve(vaultPath), resolvedPath), content);
+    return filePath;
+}