renor-engine 0.0.0-stage → 1.0.0

package/dist/extraction/eventExtractor.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EVENTS_EXTRACTION_VERSION = exports.EVENTS_MODEL = exports.repairMalformedUnicodeEscapes = exports.stripExtractorCodeFence = exports.ExtractorParseError = void 0;
+exports.chronicleEnabled = chronicleEnabled;
+exports.extractEvents = extractEvents;
+exports.extractEventsWithRetry = extractEventsWithRetry;
+const typedFacts_1 = require("./typedFacts");
+Object.defineProperty(exports, "ExtractorParseError", { enumerable: true, get: function () { return typedFacts_1.ExtractorParseError; } });
+Object.defineProperty(exports, "stripExtractorCodeFence", { enumerable: true, get: function () { return typedFacts_1.stripExtractorCodeFence; } });
+Object.defineProperty(exports, "repairMalformedUnicodeEscapes", { enumerable: true, get: function () { return typedFacts_1.repairMalformedUnicodeEscapes; } });
+/**
+ * C3 chronicle event extraction (HYP-20260921-chronicle-extraction, ADR-0003
+ * §4 payload schema for the event lane). v1 schema only — when, event,
+ * entities — frozen prompt + model. `when` REPRODUCES THE USER'S OWN WORDING
+ * ("last Saturday", relative days, times); the row's valid_from is derived
+ * from the note's frontmatter date and stays NULL when unknown — a relative
+ * `when` is never resolved into an invented normalized date. Ledger KILLs
+ * bound this module: N12/N14/N16b/N20/N25 (extractor-prompt variants are a
+ * structural ceiling — no v2/v3/v4 prompt iteration), H5 (one-pass multi-head
+ * — 48% row loss, so this extracts events only), and H6 (zero-yield prefilter
+ * KILL — the hash-keyed skip is the only cost control). Parse failures are
+ * EXPLICIT extractor-parse-errors, retried ≤3 times, never silently `[]`, and
+ * never cached (pipeline resets the note hash so the next pass retries).
+ */
+exports.EVENTS_MODEL = 'gemma4:31b';
+/** extraction_version = schema:model (ADR §4): hash-keyed cache key component. */
+exports.EVENTS_EXTRACTION_VERSION = `events-v1:${exports.EVENTS_MODEL}`;
+/** RENOR_CHRONICLE (default OFF). Opt in with 1/true/yes/on. No default flip. */
+function chronicleEnabled(env = process.env) {
+    const raw = (env.RENOR_CHRONICLE ?? '').trim().toLowerCase();
+    return raw === '1' || raw === 'true' || raw === 'yes' || raw === 'on';
+}
+const SYSTEM_PROMPT = `Extract KEY EVENTS the USER describes from the note. Return STRICT JSON only — no YAML, no markdown code fences, no commentary.
+
+Shape: {"events": [{"when": "<exactly the user's own wording>", "event": "<short phrase, 3-8 words>", "entities": ["<comma-separated entities>"]}]}
+
+Rules:
+- when: reproduce the user's own wording for the time ("last Saturday", "yesterday", "March 3rd", "this morning") — NEVER convert it to a normalized or invented date
+- event: short description of what happened (did / attended / started / cancelled / bought / met / visited / celebrated / completed / plans)
+- entities: people, places, things involved; omit if none
+- Only events the USER did or experienced — not the assistant, not hypotheticals, not third parties
+- Each distinct event ONCE. Extract 0-15 events.
+- Do NOT extract from frontmatter metadata.`;
+async function extractEvents(client, noteTitle, noteBody) {
+    // Truncate body to keep the prompt bounded (same budget as the legacy extractor).
+    const body = noteBody.substring(0, 3000);
+    const response = await client.chat.completions.create({
+        model: exports.EVENTS_MODEL,
+        temperature: 0,
+        response_format: { type: 'json_object' },
+        messages: [
+            { role: 'system', content: SYSTEM_PROMPT },
+            { role: 'user', content: `Note: "${noteTitle}"\n\n${body}` },
+        ],
+    });
+    const content = response.choices?.[0]?.message?.content;
+    if (!content || !content.trim()) {
+        throw new typedFacts_1.ExtractorParseError('extractor-parse-error: event extraction returned empty content');
+    }
+    // JSON-strict after fence-strip: a fenced or bare response parses; YAML,
+    // truncated JSON, or commentary still fails hard as an explicit parse error.
+    let parsed;
+    try {
+        parsed = JSON.parse((0, typedFacts_1.repairMalformedUnicodeEscapes)((0, typedFacts_1.stripExtractorCodeFence)(content)));
+    }
+    catch {
+        throw new typedFacts_1.ExtractorParseError(`extractor-parse-error: event extraction returned non-JSON response (head: ${content.slice(0, 80)})`);
+    }
+    if (!parsed || typeof parsed !== 'object' || !Array.isArray(parsed.events)) {
+        throw new typedFacts_1.ExtractorParseError('extractor-parse-error: event extraction response is missing an events array');
+    }
+    const events = [];
+    for (const raw of parsed.events) {
+        const when = raw?.when === undefined || raw?.when === null ? '' : String(raw.when).trim();
+        const event = raw?.event === undefined || raw?.event === null ? '' : String(raw.event).trim();
+        if (!when || !event)
+            continue; // malformed rows are dropped, not fatal
+        const extracted = { when, event };
+        const entities = raw?.entities;
+        if (Array.isArray(entities) && entities.length > 0) {
+            const cleaned = entities.map((e) => String(e).trim()).filter(Boolean);
+            if (cleaned.length > 0)
+                extracted.entities = cleaned;
+        }
+        else if (typeof entities === 'string' && entities.trim()) {
+            // The research prompt asked for comma-separated entities; accept either shape.
+            const cleaned = entities.split(',').map((e) => e.trim()).filter(Boolean);
+            if (cleaned.length > 0)
+                extracted.entities = cleaned;
+        }
+        events.push(extracted);
+    }
+    return events;
+}
+/**
+ * Retry wrapper: parse failures are retried up to MAX_EXTRACT_ATTEMPTS total;
+ * the final failure is rethrown explicitly (never cached, never silent []).
+ * Non-parse errors (network, auth) propagate immediately.
+ */
+async function extractEventsWithRetry(extract, noteTitle, noteBody) {
+    let lastError;
+    for (let attempt = 1; attempt <= typedFacts_1.MAX_EXTRACT_ATTEMPTS; attempt++) {
+        try {
+            return await extract(noteTitle, noteBody);
+        }
+        catch (err) {
+            if (!(err instanceof typedFacts_1.ExtractorParseError))
+                throw err;
+            lastError = err;
+        }
+    }
+    throw lastError;
+}

package/dist/extraction/extractionClient.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isExtractorSpecificProvider = isExtractorSpecificProvider;
+exports.resolveExtractorClientConfig = resolveExtractorClientConfig;
+exports.createExtractorClient = createExtractorClient;
+exports.openExtractorClient = openExtractorClient;
+const ollamaChat_1 = require("../evidence/ollamaChat");
+const keyPool_1 = require("../evidence/keyPool");
+/**
+ * Whether the resolved provider is one of the extractor-specific providers (the
+ * dedicated RENOR_EXTRACTOR_* slot or the Ollama Cloud pool) rather than the
+ * generic OPENAI_API_KEY fallback.
+ *
+ * The legacy `LLM_EXTRACTION` fact path reads this to choose its model id: it
+ * names `FACTS_MODEL` only for an extractor-specific provider, and on the generic
+ * fallback it keeps the fact extractor's own default, which is the model `main`
+ * sent there. The structured-row lanes are NOT decided here — their extractors
+ * name `FACTS_MODEL` on every provider branch, including the fallback, which is
+ * also what `main` did. Changing that is a separate decision, recorded as a
+ * finding in this branch's review packet, not a property this helper can fix.
+ */
+function isExtractorSpecificProvider(config) {
+    return !!config && config.provider !== 'openai-fallback';
+}
+const DEFAULT_BASE_URL = 'https://ollama.com/v1';
+function nonEmpty(value) {
+    const trimmed = (value ?? '').trim();
+    return trimmed === '' ? undefined : trimmed;
+}
+function splitKeys(value) {
+    return (value ?? '').split(',').map(key => key.trim()).filter(Boolean);
+}
+function resolveExtractorClientConfig(env = process.env, model) {
+    const dedicatedKeys = [
+        ...splitKeys(env.RENOR_EXTRACTOR_API_KEYS),
+        ...splitKeys(env.RENOR_EXTRACTOR_API_KEY),
+    ];
+    if (dedicatedKeys.length > 0) {
+        return {
+            baseUrl: nonEmpty(env.RENOR_EXTRACTOR_BASE_URL) ?? DEFAULT_BASE_URL,
+            keys: dedicatedKeys,
+            model,
+            provider: 'dedicated',
+            keyEnvNames: [
+                ...(splitKeys(env.RENOR_EXTRACTOR_API_KEYS).length > 0 ? ['RENOR_EXTRACTOR_API_KEYS'] : []),
+                ...(splitKeys(env.RENOR_EXTRACTOR_API_KEY).length > 0 ? ['RENOR_EXTRACTOR_API_KEY'] : []),
+            ],
+        };
+    }
+    const ollama = (0, keyPool_1.collectOllamaKeys)(env);
+    const ollamaKeys = ollama.keys;
+    const usedOllamaNames = ollama.names;
+    if (ollamaKeys.length > 0) {
+        return {
+            baseUrl: nonEmpty(env.RENOR_EXTRACTOR_BASE_URL) ?? DEFAULT_BASE_URL,
+            keys: ollamaKeys,
+            model,
+            provider: 'ollama-cloud',
+            keyEnvNames: usedOllamaNames,
+        };
+    }
+    const fallbackBase = nonEmpty(env.OPENAI_BASE_URL) ?? nonEmpty(env.EMBEDDING_BASE_URL);
+    const fallbackKey = nonEmpty(env.OPENAI_API_KEY);
+    if (fallbackKey && fallbackBase) {
+        return {
+            baseUrl: fallbackBase,
+            keys: splitKeys(env.OPENAI_API_KEY),
+            model,
+            provider: 'openai-fallback',
+            keyEnvNames: ['OPENAI_API_KEY'],
+        };
+    }
+    return null;
+}
+/**
+ * OpenAI-shaped handle over the shared chat transport. Forwards
+ * `response_format` when the extractor set it. Dropping that field made JSON
+ * mode a silent no-op.
+ */
+function createExtractorClient(config) {
+    const chat = (0, ollamaChat_1.createOllamaChat)({
+        baseUrl: config.baseUrl,
+        keys: config.keys,
+        timeoutMs: Number(process.env.RENOR_EXTRACTOR_TIMEOUT_MS ?? 180_000),
+        maxRetries: 3,
+    });
+    return {
+        chat: {
+            completions: {
+                create: async (request) => {
+                    const messages = (request.messages ?? []).filter(message => message
+                        && (message.role === 'user' || message.role === 'system')
+                        && typeof message.content === 'string');
+                    const response = await chat({
+                        model: request.model ?? config.model,
+                        messages: messages.map(message => ({
+                            role: message.role,
+                            content: message.content,
+                        })),
+                        temperature: 0,
+                        ...(request.response_format?.type === 'json_object'
+                            ? { response_format: { type: 'json_object' } }
+                            : {}),
+                    });
+                    return {
+                        choices: [{ message: { content: response.content } }],
+                        usage: {
+                            prompt_tokens: response.promptTokens,
+                            completion_tokens: response.completionTokens,
+                        },
+                    };
+                },
+            },
+        },
+    };
+}
+function openExtractorClient(model, env = process.env) {
+    const config = resolveExtractorClientConfig(env, model);
+    if (!config)
+        return null;
+    return { client: createExtractorClient(config), config };
+}

package/dist/extraction/factExtractor.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractFacts = extractFacts;
+async function extractFacts(client, noteTitle, noteBody, model = 'gpt-4o-mini') {
+    // Truncate body to ~3000 chars to stay within reasonable token budget
+    const body = noteBody.substring(0, 3000);
+    const response = await client.chat.completions.create({
+        model,
+        temperature: 0,
+        response_format: { type: 'json_object' },
+        messages: [
+            {
+                role: 'system',
+                content: `Extract factual statements from the note. Return JSON: {"facts": [{"subject": "...", "predicate": "...", "object": "...", "confidence": 0.0-1.0}]}
+
+Rules:
+- subject: the entity the fact is about (use the note title if the note is about one main entity)
+- predicate: a short verb phrase (e.g. "works_at", "uses", "depends_on", "is_a", "located_in", "deadline", "created_by")
+- object: the target entity or value
+- confidence: 0.0-1.0 based on how explicitly the fact is stated
+- Extract 0-10 facts. Only extract facts clearly stated in the text.
+- Do NOT extract facts from frontmatter metadata — those are handled separately.
+- Keep predicates consistent and snake_case.`
+            },
+            {
+                role: 'user',
+                content: `Note: "${noteTitle}"\n\n${body}`
+            }
+        ]
+    });
+    const content = response.choices[0]?.message.content;
+    if (!content) {
+        throw new Error('Fact extraction returned empty content');
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(content);
+    }
+    catch {
+        throw new Error('Fact extraction returned invalid JSON');
+    }
+    if (!parsed || typeof parsed !== 'object' || !Array.isArray(parsed.facts)) {
+        throw new Error('Fact extraction response is missing a facts array');
+    }
+    return parsed.facts.filter((f) => f.subject && f.predicate && f.object && typeof f.confidence === 'number');
+}

package/dist/extraction/factsWritePath.js

@@ -0,0 +1,179 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FACTS_EXTRACTION_VERSION = void 0;
+exports.factsWritePathEnabled = factsWritePathEnabled;
+exports.contentValidFrom = contentValidFrom;
+exports.extractFactCandidates = extractFactCandidates;
+exports.captureNoteFacts = captureNoteFacts;
+const rowStore_1 = require("../context/rowStore");
+const decision_model_1 = require("./decision-model");
+/**
+ * C2 facts write-path (ADR-0003 §4/§6, component-matrix C2): save-time typed
+ * numeric-fact capture from real markdown through the REAL index pipeline
+ * (indexVault → extraction → structured-row store). Facts flow into the C0
+ * rowStore, whose identity-keyed supersession extends the battle-tested
+ * lifecycle bitemporal model (valid_from/valid_to) to extracted rows — the
+ * markdown Memory Events Ledger stays `_mcp_`-lifecycle-only per
+ * inventory-facts (its semantics do not apply to extracted note facts), so
+ * extracted facts are NOT appended there.
+ *
+ * Flag gate: RENOR_FACTS_WRITE_PATH (default OFF). Flag off = zero decision
+ * calls, zero new writes, byte-identical shipped behavior. The ask-time
+ * evidence second pass is untouched (C2 is save-time; both compose).
+ *
+ * v1 schema only — no v2/v3/v4 prompt variants (five extractor KILLs). The
+ * extractor is the local-rules path TODAY (no live model calls, quota=0); a
+ * model-backed extractor plugs in through the DecisionModel seam.
+ */
+exports.FACTS_EXTRACTION_VERSION = 'c2-facts-v1';
+/** RENOR_FACTS_WRITE_PATH (default OFF). Opt in with 1/true/yes/on. */
+function factsWritePathEnabled(env = process.env) {
+    const raw = (env.RENOR_FACTS_WRITE_PATH ?? '').trim().toLowerCase();
+    return raw === '1' || raw === 'true' || raw === 'yes' || raw === 'on';
+}
+/** Content dates: frontmatter `session_date`/`date`; unknown stays unknown (NULL — never `now`, never invented). */
+const CONTENT_DATE_RE = /^\d{4}-\d{2}-\d{2}(T[\d:]+(\.\d+)?(Z|[+-]\d{2}:\d{2})?)?$/;
+function contentValidFrom(frontmatter) {
+    for (const key of ['session_date', 'date']) {
+        const raw = frontmatter[key];
+        if (raw instanceof Date && !Number.isNaN(raw.getTime())) {
+            return raw.toISOString().slice(0, 10); // YAML unquoted dates parse as Date; date-only UTC midnight
+        }
+        if (typeof raw === 'string' && CONTENT_DATE_RE.test(raw.trim()))
+            return raw.trim();
+    }
+    return null;
+}
+/**
+ * v1 numeric-fact candidates from gate-approved chunk text. Deterministic:
+ * sentence-split, rule-matched value/unit/verb, note title as object (the
+ * legacy extractor's same "note about one main entity" guidance). No model
+ * call, no parse-failure mode — JSON/YAML parse errors cannot arise from a
+ * local deterministic extractor by construction.
+ */
+function extractFactCandidates(text, noteTitle) {
+    if (!text || !text.trim())
+        return [];
+    const sentences = text.split(/(?<=[.!?])\s+|\n+/).map((s) => s.trim()).filter(Boolean);
+    const out = [];
+    for (const sentence of sentences) {
+        if (decision_model_1.LocalRulesDecisionModel.captureGate(sentence) !== 'fact')
+            continue;
+        const valueMatch = decision_model_1.NUMERIC_FACT_RE.exec(sentence);
+        if (!valueMatch)
+            continue;
+        const cueMatch = decision_model_1.STATIVE_CUE_RE.exec(sentence);
+        out.push({
+            value: valueMatch[1].replace(',', '.'),
+            unit: valueMatch[2] ? valueMatch[2].toLowerCase() : undefined,
+            verb: cueMatch ? cueMatch[1].toLowerCase() : undefined,
+            object: noteTitle,
+            event: sentence.length > 300 ? sentence.slice(0, 300) : sentence,
+        });
+    }
+    return out;
+}
+/**
+ * Capture one note's typed facts: per-chunk capture-gate decision → candidate
+ * extraction → dedupe adjudication against the current row with the same
+ * dedupe identity → write (structured row, or confirm-count bump on
+ * `identical`; a cross-note `identical` additionally writes the confirming
+ * note's own source-scoped row so the fact survives either note's deletion). Adjudicates against the lowest-id current row so repeated
+ * runs are deterministic. Hash-keyed skip: rows already present for
+ * (source_path, source_hash, extraction_version) → zero decisions (the
+ * pipeline additionally skips unchanged notes via note_hash before this runs).
+ */
+async function captureNoteFacts(db, args, model = (0, decision_model_1.defaultDecisionModel)()) {
+    const hashSkip = db.prepare(`SELECT COUNT(*) AS c FROM structured_rows WHERE source_path = ? AND source_hash = ? AND extraction_version = ?`).get(args.notePath, args.sourceHash, exports.FACTS_EXTRACTION_VERSION);
+    if (hashSkip.c > 0)
+        return { rowsWritten: 0, confirmBumps: 0, decisions: 0 };
+    const validFrom = contentValidFrom(args.frontmatter);
+    const findCurrent = db.prepare(`SELECT id, source_path, payload_json FROM structured_rows
+     WHERE row_kind = 'fact' AND scope = 'global' AND dedupe_key = ? AND valid_to IS NULL
+     ORDER BY id LIMIT 1`);
+    const bumpConfirm = db.prepare(`UPDATE structured_rows SET confirm_count = confirm_count + 1 WHERE row_kind = 'fact' AND scope = 'global' AND dedupe_key = ? AND valid_to IS NULL`);
+    // Does THIS note already hold a current row for the identity? Guards the
+    // cross-note confirm write against double-inserting when several chunks of
+    // the same note adjudicate `identical` against the original note's row.
+    const findOwnCurrent = db.prepare(`SELECT id FROM structured_rows
+     WHERE row_kind = 'fact' AND scope = 'global' AND dedupe_key = ? AND source_path = ? AND valid_to IS NULL
+     LIMIT 1`);
+    let rowsWritten = 0;
+    let confirmBumps = 0;
+    let decisions = 0;
+    for (const chunk of args.chunks) {
+        const gate = await model.decide({ task: 'capture_gate', text: chunk.text });
+        decisions++;
+        if (gate.task !== 'capture_gate' || gate.decision !== 'fact')
+            continue;
+        for (const candidate of extractFactCandidates(chunk.text, args.noteTitle)) {
+            const dedupeKey = (0, rowStore_1.dedupeKeyFor)({
+                rowKind: 'fact',
+                sourcePath: args.notePath,
+                sourceChunkId: chunk.id,
+                sourceHash: args.sourceHash,
+                extractionVersion: exports.FACTS_EXTRACTION_VERSION,
+                validFrom,
+                payload: candidate,
+            });
+            const existing = findCurrent.get(dedupeKey);
+            const existingCandidate = existing
+                ? JSON.parse(existing.payload_json)
+                : null;
+            const adjudication = await model.decide({
+                task: 'dedupe_adjudication',
+                candidate,
+                existing: existingCandidate,
+            });
+            decisions++;
+            if (adjudication.task !== 'dedupe_adjudication')
+                continue;
+            if (adjudication.decision === 'identical') {
+                bumpConfirm.run(dedupeKey);
+                confirmBumps++;
+                // Same-note `identical` (re-extraction/edit): bump only, no duplicate
+                // row (original C2 behavior). Cross-note `identical` — this note is
+                // NOT the source of the compared row — must ALSO write its own
+                // source-scoped row: the dedupe key has no source, so a bump-only
+                // write leaves the fact pinned solely to the original note's row,
+                // whose FK cascade dies with that note while this note still asserts
+                // the fact (unsurfaceable via the retrieval-hit join).
+                if (!existing || existing.source_path === args.notePath)
+                    continue;
+                const own = findOwnCurrent.get(dedupeKey, args.notePath);
+                if (own)
+                    continue; // already captured from another chunk/run of this note
+                (0, rowStore_1.insertStructuredRows)(db, [
+                    {
+                        rowKind: 'fact',
+                        sourcePath: args.notePath,
+                        sourceChunkId: chunk.id,
+                        sourceHash: args.sourceHash,
+                        extractionVersion: exports.FACTS_EXTRACTION_VERSION,
+                        validFrom,
+                        payload: candidate,
+                    },
+                ], { skipSupersession: true });
+                rowsWritten++;
+                continue;
+            }
+            // 'updated' and 'distinct' both write; the rowStore's identity-keyed
+            // supersession (never blanket newest-wins — N18 KILL) closes the
+            // collided current row only when both content dates are known and the
+            // new source is not older. NULL valid_from never supersedes.
+            (0, rowStore_1.insertStructuredRows)(db, [
+                {
+                    rowKind: 'fact',
+                    sourcePath: args.notePath,
+                    sourceChunkId: chunk.id,
+                    sourceHash: args.sourceHash,
+                    extractionVersion: exports.FACTS_EXTRACTION_VERSION,
+                    validFrom,
+                    payload: candidate,
+                },
+            ]);
+            rowsWritten++;
+        }
+    }
+    return { rowsWritten, confirmBumps, decisions };
+}

package/dist/extraction/preferenceExtractor.js

@@ -0,0 +1,153 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PREFS_EXTRACTION_VERSION = exports.PREFS_MODEL = exports.repairMalformedUnicodeEscapes = exports.stripExtractorCodeFence = exports.ExtractorParseError = void 0;
+exports.prefsEnabled = prefsEnabled;
+exports.looksLikeOneOff = looksLikeOneOff;
+exports.extractPreferences = extractPreferences;
+exports.extractPreferencesWithRetry = extractPreferencesWithRetry;
+const typedFacts_1 = require("./typedFacts");
+Object.defineProperty(exports, "ExtractorParseError", { enumerable: true, get: function () { return typedFacts_1.ExtractorParseError; } });
+Object.defineProperty(exports, "stripExtractorCodeFence", { enumerable: true, get: function () { return typedFacts_1.stripExtractorCodeFence; } });
+Object.defineProperty(exports, "repairMalformedUnicodeEscapes", { enumerable: true, get: function () { return typedFacts_1.repairMalformedUnicodeEscapes; } });
+/**
+ * C4 standing-preference extraction (HYP-20260921-prefs-extraction, ADR-0003
+ * §4 payload schema for the preference lane). v1 schema only — statement,
+ * kind — frozen prompt + model. `kind` is an UNVALIDATED RENDER-ONLY enum
+ * (N12 KILL: taxonomy reliability is extractor-limited — never gate behavior
+ * on it); it is NOT part of the dedupe key (norm(statement) is).
+ *
+ * Standing-vs-one-off is NOT prompt-only: the extractor prompt instructs the
+ * model to reject one-off events, and a code-level structural guard
+ * (`looksLikeOneOff`) drops extracted rows whose statement carries past-tense
+ * one-off markers ("yesterday", "last <day>", "-ed <unit> ago", …). The
+ * synthetic fixture enforces this both ways: "I always run Tuesdays" survives;
+ * "I ran 5km yesterday" is rejected even when the model (stub) emits it.
+ *
+ * Ledger KILLs bound this module: N12/N14/N16b/N20/N25 (no prompt iteration
+ * beyond v1), H5 (one-pass multi-head KILL — this extracts preferences only),
+ * H6 (yield-prefilter KILL, skip ceiling 43.0% — the hash-keyed skip is the
+ * only cost control), N15 (cap-80 KILL — selection is retrieval-scoped in the
+ * composer, never a bigger cap). Parse failures are EXPLICIT
+ * extractor-parse-errors, retried ≤3 times, never silently `[]`, and never
+ * cached (pipeline resets the note hash so the next pass retries).
+ */
+exports.PREFS_MODEL = 'gemma4:31b';
+/** extraction_version = schema:model (ADR §4): hash-keyed cache key component. */
+exports.PREFS_EXTRACTION_VERSION = `prefs-v1:${exports.PREFS_MODEL}`;
+/** RENOR_PREFS (default OFF). Opt in with 1/true/yes/on. No default flip. */
+function prefsEnabled(env = process.env) {
+    const raw = (env.RENOR_PREFS ?? '').trim().toLowerCase();
+    return raw === '1' || raw === 'true' || raw === 'yes' || raw === 'on';
+}
+/**
+ * Structural guard for the standing-vs-one-off fixture (must not rely on the
+ * prompt alone): a statement that describes a completed past-tense one-off
+ * action is NOT a standing preference, even if the extractor emitted it.
+ * Dataset-free — anchored on explicit temporal one-off markers only, never on
+ * topic words (a standing rule about running Tuesdays must survive).
+ */
+function looksLikeOneOff(statement) {
+    const s = statement.toLowerCase();
+    const markers = [
+        /\byesterday\b/,
+        /\blast (night|week|month|year|monday|tuesday|wednesday|thursday|friday|saturday|sunday)\b/,
+        /\bthis (morning|afternoon|evening)\b/,
+        /\b(earlier|ago)\b/,
+        /\bjust (ran|did|finished|completed|bought|met|visited|attended|started|watched)\b/,
+        /\b(i|we|he|she|they) (ran|walked|went|did|finished|completed|bought|met|visited|attended|watched|ate|drank|had) (yesterday|this morning|last )/,
+        /\b(had|have) (just|already) /,
+    ];
+    return markers.some((re) => re.test(s));
+}
+const SYSTEM_PROMPT = `Extract STANDING PREFERENCES, CONSTRAINTS and durable PROFILE FACTS the USER asserts about themselves. Return STRICT JSON only — no YAML, no markdown code fences, no commentary.
+
+Shape: {"prefs": [{"statement": "<first-person-compatible standing rule>", "kind": "like" | "dislike" | "policy" | "attribute"}]}
+
+Rules:
+- statement: durable rule or attribute as the user would say it (likes/dislikes, aversions, dietary restrictions, allergies, style/communication/tool preferences, standing policies like "I never...", "I always...", "I prefer... over...", durable personal attributes like job, family, pets, home, skills)
+- kind: one of like, dislike, policy, attribute (best guess; never leave empty)
+- STANDING only: what is persistently true or desired — NOT one-off events ("I ran 5km yesterday" is an event, "I always run Tuesdays" is a preference), NOT questions, NOT assistant suggestions, NOT hypotheticals
+- Only preferences the USER asserted — first-person-compatible
+- Each distinct preference ONCE. Extract 0-15 preferences.
+- Do NOT extract from frontmatter metadata.`;
+async function extractPreferences(client, noteTitle, noteBody) {
+    // Truncate body to keep the prompt bounded (same budget as the other lanes).
+    const body = noteBody.substring(0, 3000);
+    const response = await client.chat.completions.create({
+        model: exports.PREFS_MODEL,
+        temperature: 0,
+        response_format: { type: 'json_object' },
+        messages: [
+            { role: 'system', content: SYSTEM_PROMPT },
+            { role: 'user', content: `Note: "${noteTitle}"\n\n${body}` },
+        ],
+    });
+    const content = response.choices?.[0]?.message?.content;
+    if (!content || !content.trim()) {
+        throw new typedFacts_1.ExtractorParseError('extractor-parse-error: preference extraction returned empty content');
+    }
+    // JSON-strict after fence-strip: a fenced or bare response parses; YAML,
+    // truncated JSON, or commentary still fails hard as an explicit parse error.
+    let parsed;
+    try {
+        parsed = JSON.parse((0, typedFacts_1.repairMalformedUnicodeEscapes)((0, typedFacts_1.stripExtractorCodeFence)(content)));
+    }
+    catch {
+        throw new typedFacts_1.ExtractorParseError(`extractor-parse-error: preference extraction returned non-JSON response (head: ${content.slice(0, 80)})`);
+    }
+    if (Array.isArray(parsed)) {
+        // Schema-drift tolerance: some gemma4 responses emit the bare prefs array
+        // without the {"prefs": ...} wrapper. Valid JSON either way; strict on shape.
+        parsed.prefs = parsed;
+    }
+    else if (parsed && typeof parsed === 'object' && !Array.isArray(parsed.prefs)) {
+        // Wrapper-key drift: gemma4 sometimes renames the wrapper key (e.g.
+        // "merchants") or emits a single object. Rows without a non-empty
+        // `statement` are dropped below, so mis-shaped rows can never become false
+        // preferences — empty is the worst case.
+        const firstArray = Object.values(parsed).find((v) => Array.isArray(v) && v.length > 0 && typeof v[0] === 'object' && v[0] !== null);
+        if (firstArray)
+            parsed.prefs = firstArray;
+        else
+            parsed.prefs = [parsed];
+    }
+    if (!parsed || typeof parsed !== 'object' || !Array.isArray(parsed.prefs)) {
+        throw new typedFacts_1.ExtractorParseError('extractor-parse-error: preference extraction response is missing a prefs array');
+    }
+    const prefs = [];
+    for (const raw of parsed.prefs) {
+        const statement = raw?.statement === undefined || raw?.statement === null ? '' : String(raw.statement).trim();
+        if (!statement)
+            continue; // malformed rows are dropped, not fatal
+        // Structural standing-vs-one-off guard: one-off past-tense events are
+        // rejected HERE, not just in the prompt (synthetic-fixture contract).
+        if (looksLikeOneOff(statement))
+            continue;
+        const pref = { statement };
+        const kind = raw?.kind;
+        if (kind !== undefined && kind !== null && String(kind).trim()) {
+            pref.kind = String(kind).trim(); // unvalidated render-only enum (N12)
+        }
+        prefs.push(pref);
+    }
+    return prefs;
+}
+/**
+ * Retry wrapper: parse failures are retried up to MAX_EXTRACT_ATTEMPTS total;
+ * the final failure is rethrown explicitly (never cached, never silent []).
+ * Non-parse errors (network, auth) propagate immediately.
+ */
+async function extractPreferencesWithRetry(extract, noteTitle, noteBody) {
+    let lastError;
+    for (let attempt = 1; attempt <= typedFacts_1.MAX_EXTRACT_ATTEMPTS; attempt++) {
+        try {
+            return await extract(noteTitle, noteBody);
+        }
+        catch (err) {
+            if (!(err instanceof typedFacts_1.ExtractorParseError))
+                throw err;
+            lastError = err;
+        }
+    }
+    throw lastError;
+}