renor-engine 0.0.0-stage → 1.0.0

package/dist/evidence/secondPass.js

@@ -0,0 +1,456 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EvidenceExtractor = exports.EvidenceReplyError = exports.EVIDENCE_REASONING_EFFORTS = exports.EVIDENCE_SESSION_CHAR_CAP = exports.MAX_EVIDENCE_SESSIONS = exports.EVIDENCE_MODEL_DEFAULT = exports.EVIDENCE_PROMPT_TEMPLATE_SCOPED = exports.EVIDENCE_PROMPT_TEMPLATE_EXHAUSTIVE = exports.EVIDENCE_PROMPT_TEMPLATE = void 0;
+exports.evidenceEnumerateMode = evidenceEnumerateMode;
+exports.evidenceEnumerateEnabled = evidenceEnumerateEnabled;
+exports.scoreBodyOverlap = scoreBodyOverlap;
+exports.bodyRankEnabled = bodyRankEnabled;
+exports.loadEvidenceSessionsFromVault = loadEvidenceSessionsFromVault;
+exports.renderEvidencePrompt = renderEvidencePrompt;
+exports.parseEvidenceItems = parseEvidenceItems;
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_path_1 = __importDefault(require("node:path"));
+const parser_1 = require("../indexer/parser");
+const evidenceCache_1 = require("./evidenceCache");
+/**
+ * H10-v4 second-pass, question-conditioned evidence extraction (product path).
+ *
+ * Frozen mechanism (champion = 453/500 = 90.6%, docs/evals/results/
+ * H10-V4-FULL500-20260919.md): given a question and the sessions retrieval
+ * already selected, the extractor (gemma4:31b) lists every distinct relevant
+ * item/event/amount with dates. It never computes totals and never sees gold.
+ *
+ * Productization adds:
+ *   - content-addressed caching (exact rendered prompt -> parsed items, and,
+ *     for a day, a reply that was not a table: EVIDENCE_FAILURE_TTL_MS);
+ *   - session selection matching the promoted arm (20 sessions, 6,000 chars/session);
+ *   - gating (off | auto | always), default off (src/evidence/gate.ts).
+ */
+exports.EVIDENCE_PROMPT_TEMPLATE = `You extract evidence items from a user's dated conversation history.
+
+QUESTION: {question}
+
+Below are the sessions (with dates) that a memory system retrieved for this question.
+
+TASK: List EVERY distinct item, event, or amount mentioned in the sessions that could be
+relevant to answering the question. Rules:
+- One entry per distinct item (e.g., each product, each trip, each device, each course, each amount).
+- "action" = what happened (bought / visited / completed / raised / inherited / ...).
+- "amount" = numeric value + unit when stated (e.g., "3 days", "$120", "100 points"); else "".
+- "date" = the session/mention date when available; else "".
+- Do NOT compute any totals. Do NOT merge different items. Include every candidate even if uncertain.
+- Include items the question might count, even when the sessions mention them in passing.
+
+SESSIONS:
+{sessions}
+
+Respond with ONLY minified JSON, no markdown:
+{{"items":[{{"item":"...","action":"...","amount":"...","date":"..."}}]}}`;
+/**
+ * EXHAUSTIVE enumeration variant of the evidence prompt (RENOR_EVIDENCE_ENUMERATE,
+ * default OFF — opt in with 1/true/yes/on).
+ *
+ * Why this exists, measured: the shipped prompt asks for items "that could be
+ * relevant to answering the question" — a relevance FILTER applied to an
+ * enumeration task. On the champion's 23 count/aggregate wrongs that filter is
+ * the binding constraint: the evidence table holds a mean of 5.3 items, and 13 of
+ * the 23 have FEWER items than the gold count requires. The count-contract arm
+ * proved the reader's arithmetic is correct — it lists 2 items and answers "2"
+ * for gold 3 — so the items are simply absent from the table it counts.
+ *
+ * Prompt-variant A/B on one case (gpt4_31ff4165, "How many health-related devices
+ * do I use in a day?", gold 4) at temperature 0:
+ *
+ *   shipped prompt    :  4 items,  134 completion tokens
+ *   this variant      : 27 items,  936 completion tokens
+ *
+ * The variant asks for everything mentioned and states that completeness is the
+ * only goal, that missing an item is a failure, and that including an irrelevant
+ * item is NOT a failure — the exact inverse of the shipped relevance filter.
+ *
+ * Scope discipline: this changes the EVIDENCE prompt only. The frozen
+ * judge/extractor model, the retrieval ranking, the schema, the item payload and
+ * the fact/chronicle/preference lanes are untouched. Default OFF, so shipped
+ * behaviour is byte-identical unless an eval arm opts in.
+ */
+exports.EVIDENCE_PROMPT_TEMPLATE_EXHAUSTIVE = `You extract a COMPLETE inventory of items from a user's dated conversation history.
+
+QUESTION: {question}
+
+Below are the sessions (with dates) that a memory system retrieved for this question.
+
+TASK: List EVERY distinct item, device, object, purchase, place, person, activity, event or amount mentioned ANYWHERE in the sessions below — whether or not it appears relevant to the question. Completeness is the ONLY goal.
+Rules:
+- COMPLETENESS OVER BREVITY. If the sessions mention ten things, list all ten. Do not summarise, do not select, do not rank, do not judge relevance.
+- Missing an item is a failure. Including an item that turns out to be irrelevant is NOT a failure.
+- One entry per distinct item (e.g., each product, each device, each trip, each course, each amount).
+- Do NOT merge different items. Do NOT compute any totals.
+- "action" = what happened (bought / visited / completed / raised / inherited / used / ...).
+- "amount" = numeric value + unit when stated (e.g., "3 days", "$120", "100 points"); else "".
+- "date" = the session/mention date when available; else "".
+
+SESSIONS:
+{sessions}
+
+Respond with ONLY minified JSON, no markdown:
+{{"items":[{{"item":"...","action":"...","amount":"...","date":"..."}}]}}`;
+function evidenceEnumerateMode(env = process.env) {
+    const raw = (env.RENOR_EVIDENCE_ENUMERATE ?? '').trim().toLowerCase();
+    if (raw === 'scoped')
+        return 'scoped';
+    if (raw === '1' || raw === 'true' || raw === 'yes' || raw === 'on')
+        return 'all';
+    return 'off';
+}
+/** Back-compat boolean form (true for either enumeration mode). */
+function evidenceEnumerateEnabled(env = process.env) {
+    return evidenceEnumerateMode(env) !== 'off';
+}
+/**
+ * SCOPED enumeration template: the model first names the entity type the question
+ * counts, then lists every instance of that type. Deliberately instructs the model
+ * to EXCLUDE the incidental magnitudes it is not being asked to count (steps per
+ * day, hours of sleep, battery pack sizes) — the exact mass that made `all`
+ * unusable. Gold-blind: the only input is the user's question and the retrieved
+ * sessions.
+ */
+exports.EVIDENCE_PROMPT_TEMPLATE_SCOPED = `You extract a COMPLETE inventory of one specific kind of entity from a user's dated conversation history.
+
+QUESTION: {question}
+
+Below are the sessions (with dates) that a memory system retrieved for this question.
+
+STEP 1 — From the QUESTION, decide the single kind of thing being counted or totalled. Examples: "how many items of clothing" -> garments; "how many devices do I use" -> devices; "how many albums did I buy" -> albums; "how much did I spend in total" -> purchases with an amount; "how many properties did I view" -> properties.
+
+STEP 2 — List EVERY instance of THAT kind found ANYWHERE in the sessions below. Completeness is the only goal.
+Rules:
+- Do NOT list incidental magnitudes of the same sentences. If counting devices, do NOT list "10,000 steps", "7-9 hours of sleep", "size 13 batteries" or "8-10 glasses of fluid" — those are not devices.
+- Do NOT summarise, do NOT select, do NOT rank, do NOT judge relevance.
+- Missing an instance of the counted kind is a failure. Including one that turns out to be irrelevant is NOT a failure.
+- Keep each entry short: the entity itself, plus the amount/detail if the question is about an amount.
+- Do NOT merge different instances. Do NOT compute any totals.
+
+SESSIONS:
+{sessions}
+
+Respond with ONLY minified JSON, no markdown:
+{{"items":[{{"item":"...","action":"...","amount":"...","date":"..."}}]}}`;
+exports.EVIDENCE_MODEL_DEFAULT = 'gemma4:31b';
+exports.MAX_EVIDENCE_SESSIONS = 20;
+exports.EVIDENCE_SESSION_CHAR_CAP = 6000;
+/** The `reasoning_effort` values OpenAI-compatible providers share. Which ones a model accepts is the provider's call. */
+exports.EVIDENCE_REASONING_EFFORTS = ['none', 'minimal', 'low', 'medium', 'high'];
+/**
+ * H9-family stop list (same shape as mvp/agentMemory.ts FTS_STOP_WORDS).
+ */
+const BODY_RANK_STOP_WORDS = new Set([
+    'the', 'a', 'an', 'is', 'are', 'was', 'were', 'what', 'which', 'who', 'where', 'when',
+    'why', 'how', 'do', 'does', 'did', 'to', 'for', 'of', 'in', 'on', 'at', 'with', 'and',
+    'or', 'my', 'your', 'our', 'their', 'his', 'her', 'it', 'this', 'that', 'about',
+]);
+/** Unicode-aware lexical tokens: letter/number runs, 2..64 chars (H9 family). */
+function bodyRankTokens(text) {
+    return (text.toLowerCase().match(/[\p{L}\p{N}]{2,64}/gu) ?? []).slice(0, 20000);
+}
+/**
+ * Deterministic, gold-blind lexical query-term overlap between a query and a
+ * candidate note body: total frequency of each distinct non-stop query term in
+ * the body. Zero model calls and zero embeddings at query time.
+ */
+function scoreBodyOverlap(query, body) {
+    const queryTerms = new Set(bodyRankTokens(query).filter(term => !BODY_RANK_STOP_WORDS.has(term)));
+    if (queryTerms.size === 0)
+        return 0;
+    const counts = new Map();
+    for (const token of bodyRankTokens(body))
+        counts.set(token, (counts.get(token) ?? 0) + 1);
+    let score = 0;
+    for (const term of queryTerms)
+        score += counts.get(term) ?? 0;
+    return score;
+}
+/** Opt-in kill-switch for body-relevance selection; default off. */
+function bodyRankEnabled(env = process.env) {
+    const raw = (env.RENOR_EVIDENCE_BODY_RANK ?? '').trim().toLowerCase();
+    return raw === '1' || raw === 'true' || raw === 'yes' || raw === 'on';
+}
+/**
+ * Walk ranked hits as session identities, then hydrate each selected session
+ * from the complete source note. Retrieved chunk text is never extractor input.
+ * Unreadable/virtual/out-of-vault paths are skipped and later hits backfill.
+ *
+ * Default (RENOR_EVIDENCE_BODY_RANK off): the first maxSessions unique notes by
+ * encounter rank. With RENOR_EVIDENCE_BODY_RANK=1: every unique candidate note
+ * among the hits is hydrated (same ≤charCap truncation), scored by
+ * `scoreBodyOverlap`, and the top maxSessions are selected by
+ * (score desc, hit rank asc, notePath asc). Deterministic and gold-blind;
+ * per-session hydrated text and therefore extraction prompt bytes are
+ * unchanged, so the evidence content-addressed cache stays valid.
+ */
+async function loadEvidenceSessionsFromVault(hits, vaultPath, opts = {}) {
+    const maxSessions = opts.maxSessions ?? exports.MAX_EVIDENCE_SESSIONS;
+    const charCap = opts.charCap ?? exports.EVIDENCE_SESSION_CHAR_CAP;
+    if (maxSessions <= 0)
+        throw new Error('maxSessions must be > 0');
+    if (charCap <= 0)
+        throw new Error('charCap must be > 0');
+    const bodyRank = opts.bodyRank ?? bodyRankEnabled();
+    const root = node_path_1.default.resolve(vaultPath);
+    const seen = new Set();
+    const candidates = [];
+    for (let hitRank = 0; hitRank < hits.length; hitRank++) {
+        const hit = hits[hitRank];
+        if (!hit.notePath || seen.has(hit.notePath))
+            continue;
+        seen.add(hit.notePath);
+        const candidate = node_path_1.default.isAbsolute(hit.notePath)
+            ? node_path_1.default.resolve(hit.notePath)
+            : node_path_1.default.resolve(root, hit.notePath);
+        const rel = node_path_1.default.relative(root, candidate);
+        if (rel === '..' || rel.startsWith(`..${node_path_1.default.sep}`) || node_path_1.default.isAbsolute(rel))
+            continue;
+        let raw;
+        try {
+            raw = await promises_1.default.readFile(candidate, 'utf8');
+        }
+        catch {
+            continue;
+        }
+        const parsedBody = (0, parser_1.parseNote)(candidate, raw).body;
+        const body = opts.transformBody ? opts.transformBody(parsedBody) : parsedBody;
+        if (!body)
+            continue;
+        const text = body.length > charCap ? `${body.slice(0, charCap)} …[truncated]` : body;
+        candidates.push({ stem: hit.notePath, date: hit.session_date, text, hitRank });
+        if (!bodyRank && candidates.length >= maxSessions)
+            break;
+    }
+    // Flag-off path must be byte-identical to shipped behavior — strip the
+    // internal hitRank before returning (review finding P2-1).
+    if (!bodyRank)
+        return candidates.map(({ hitRank, ...session }) => session);
+    return selectSessionsByBodyOverlap(opts.query ?? '', candidates).slice(0, maxSessions);
+}
+/**
+ * Body-relevance selection: score desc, then hit rank asc, then notePath asc.
+ * Fully deterministic; a zero-score query degrades to encounter order.
+ */
+function selectSessionsByBodyOverlap(query, candidates) {
+    const scored = candidates.map(candidate => ({
+        candidate,
+        score: scoreBodyOverlap(query, candidate.text),
+    }));
+    scored.sort((a, b) => b.score - a.score
+        || a.candidate.hitRank - b.candidate.hitRank
+        || (a.candidate.stem < b.candidate.stem ? -1 : a.candidate.stem > b.candidate.stem ? 1 : 0));
+    return scored.map(({ candidate }) => ({
+        stem: candidate.stem,
+        date: candidate.date,
+        text: candidate.text,
+    }));
+}
+function sessionBlock(session) {
+    const date = session.date ?? '';
+    return `--- Session dated ${date} ---\n${session.text}`;
+}
+/** Exact prompt the extractor receives; the cache keys on this string. */
+function renderEvidencePrompt(query, sessions) {
+    const mode = evidenceEnumerateMode();
+    const template = mode === 'scoped' ? exports.EVIDENCE_PROMPT_TEMPLATE_SCOPED
+        : mode === 'all' ? exports.EVIDENCE_PROMPT_TEMPLATE_EXHAUSTIVE
+            : exports.EVIDENCE_PROMPT_TEMPLATE;
+    return template
+        .replace('{question}', query)
+        .replace('{sessions}', sessions.map(sessionBlock).join('\n\n'));
+}
+/**
+ * The extractor answered, and its answer is not a table: it did not parse, or it stopped at the token limit. This is
+ * the one failure a search remembers (EVIDENCE_FAILURE_TTL_MS); an error before any answer is not. The message is the
+ * parse error's, so a caller that reads messages reads what it read before.
+ */
+class EvidenceReplyError extends Error {
+}
+exports.EvidenceReplyError = EvidenceReplyError;
+/**
+ * Fail-fast parse: malformed items JSON throws; it is never cached.
+ *
+ * A reply the strict parse rejects is repaired for each malformed shape extractors were seen to write (2026-10-03
+ * benchmark runs; tests/fixtures/evidence-replies.json), and the first repair whose result is, whole, a JSON object
+ * with an items list gives the table. A well-formed object is found inside surrounding text, as it always was; a
+ * repaired one is not, because a sentence that only quotes malformed JSON (a note's copy of the prompt's example) is no
+ * table. A repair changes structure only, never a character inside a string, so no value is guessed. Any other reply
+ * still throws the strict parse's own error.
+ */
+function parseEvidenceItems(raw) {
+    const s = raw.trim().replace(/^```(?:json)?|```$/gm, '').trim();
+    try {
+        return parseItemsObject(s);
+    }
+    catch (err) {
+        for (const repaired of repairedReplies(s)) {
+            try {
+                return itemsFromPayload(JSON.parse(repaired));
+            }
+            catch {
+                // Not this shape.
+            }
+        }
+        throw err;
+    }
+}
+/** A JSON string (or the one the reply ends inside), a run of `{` or a run of `}`: a brace inside a string is text. */
+const STRING_OR_BRACE_RUN = /"(?:[^"\\]|\\[\s\S])*(?:"|$)|\{+|\}+/g;
+function* repairedReplies(s) {
+    // The rows without the object around them: [{"item":...},...].
+    if (s.startsWith('['))
+        yield `{"items":${s}}`;
+    // The prompt's own example has doubled braces ({{"items":[{{...}}]}}), and models copy them, on every object or on
+    // the outer one only: a run of 2n braces outside strings stands for n.
+    const halved = s.replace(STRING_OR_BRACE_RUN, run => (run[0] === '"' || run.length % 2 === 1 ? run : run.slice(run.length / 2)));
+    if (halved !== s)
+        yield halved;
+    // A reply cut off inside the list (at the token limit): the rows before the cut, then the list and object closed.
+    // The cut row is dropped, never completed.
+    let end = -1;
+    for (const run of s.matchAll(STRING_OR_BRACE_RUN))
+        if (run[0][0] === '}')
+            end = run.index + run[0].length;
+    if (end > 0)
+        yield `${s.slice(0, end)}]}`;
+}
+function parseItemsObject(s) {
+    const m = s.match(/\{[\s\S]*\}/);
+    if (!m)
+        throw new Error('extractor response did not contain a JSON object');
+    let payload;
+    try {
+        payload = JSON.parse(m[0]);
+    }
+    catch (err) {
+        const detail = err instanceof Error ? err.message : String(err);
+        throw new Error(`extractor returned malformed JSON: ${detail}`);
+    }
+    return itemsFromPayload(payload);
+}
+function itemsFromPayload(payload) {
+    const items = payload.items;
+    if (!Array.isArray(items))
+        throw new Error('extractor JSON must contain an items list');
+    return items.map((rawItem, index) => {
+        if (!rawItem || typeof rawItem !== 'object' || Array.isArray(rawItem)) {
+            throw new Error(`extractor item ${index} must be an object`);
+        }
+        const it = rawItem;
+        const item = typeof it.item === 'string' ? it.item.trim() : '';
+        if (!item)
+            throw new Error(`extractor item ${index} must contain a non-empty item string`);
+        return {
+            item,
+            ...(it.action !== undefined ? { action: String(it.action) } : {}),
+            ...(it.amount !== undefined ? { amount: String(it.amount) } : {}),
+            ...(it.date !== undefined ? { date: String(it.date) } : {}),
+        };
+    });
+}
+/**
+ * Runs (or replays) the second pass. A cache hit performs no model call.
+ */
+class EvidenceExtractor {
+    chat;
+    cache;
+    model;
+    bounds;
+    constructor(opts) {
+        this.chat = opts.chat;
+        this.cache = opts.cache ?? null;
+        this.model = opts.model ?? exports.EVIDENCE_MODEL_DEFAULT;
+        this.bounds = opts.bounds ?? {};
+    }
+    /** The exact prompt the extractor receives for `query` over `sessions`, and the key its table is cached under. */
+    promptAndKey(query, sessions) {
+        const prompt = renderEvidencePrompt(query, sessions);
+        // A bound changes what the provider returns, so it is part of the cache
+        // identity: a bounded arm never replays an unbounded arm's table.
+        return { prompt, key: evidenceCache_1.EvidenceCache.computeKey(this.model, prompt, this.bounds) };
+    }
+    /** The key extract() caches `query` over `sessions` under, computed the one way extract() computes it. */
+    cacheKey(query, sessions) {
+        return this.promptAndKey(query, sessions).key;
+    }
+    /** The failure remembered under `key` (EVIDENCE_FAILURE_TTL_MS), or null. Never calls the model. */
+    replayFailure(key) {
+        return this.cache?.getFailure(key) ?? null;
+    }
+    /**
+     * Remembers that the extraction under `key` failed with `error`, so the same request does not pay for it again.
+     * A failure the cache cannot store is still reported, as it always was; only the next search pays again.
+     */
+    rememberFailure(key, error) {
+        try {
+            this.cache?.putFailure(key, { model: this.model, error, failedAt: Date.now() });
+        }
+        catch (err) {
+            process.stderr.write(`[evidence] could not remember a failed extraction: ${err instanceof Error ? err.message : String(err)}\n`);
+        }
+    }
+    /** The extraction cached under `key`, or null. Never calls the model. */
+    replay(key) {
+        const cached = this.cache?.get(key) ?? null;
+        if (!cached)
+            return null;
+        return {
+            items: cached.items,
+            sessions: cached.sessions,
+            fromCache: true,
+            model: cached.model,
+            usage: { promptTokens: cached.promptTokens, completionTokens: cached.completionTokens },
+            latencyMs: 0,
+        };
+    }
+    async extract(query, sessions) {
+        if (sessions.length === 0)
+            throw new Error('evidence extraction requires at least one session');
+        const { prompt, key } = this.promptAndKey(query, sessions);
+        const cached = this.replay(key);
+        if (cached)
+            return cached;
+        const res = await this.chat({
+            model: this.model,
+            messages: [{ role: 'user', content: prompt }],
+            temperature: 0,
+            ...(this.bounds.maxTokens !== undefined ? { max_tokens: this.bounds.maxTokens } : {}),
+            ...(this.bounds.reasoningEffort !== undefined ? { reasoning_effort: this.bounds.reasoningEffort } : {}),
+        });
+        let items;
+        try {
+            items = parseEvidenceItems(res.content);
+        }
+        catch (err) {
+            const detail = err instanceof Error ? err.message : String(err);
+            // Same parse failure (same retry policy), but a reply cut at a token
+            // limit says so rather than reading as malformed by the model.
+            throw new EvidenceReplyError(res.finishReason === 'length'
+                ? `extractor reply stopped at the token limit (finish_reason=length): ${detail}`
+                : detail);
+        }
+        const sessionMeta = sessions.map(s => ({ stem: s.stem, ...(s.date ? { date: s.date } : {}), chars: s.text.length }));
+        const usage = {
+            promptTokens: res.promptTokens ?? Math.ceil(prompt.length / 4),
+            completionTokens: res.completionTokens ?? Math.ceil(res.content.length / 4),
+        };
+        this.cache?.put(key, {
+            items,
+            sessions: sessionMeta,
+            model: this.model,
+            question: query,
+            promptTokens: usage.promptTokens,
+            completionTokens: usage.completionTokens,
+            createdAt: new Date().toISOString(),
+        });
+        return { items, sessions: sessionMeta, fromCache: false, model: this.model, usage, latencyMs: res.latencyMs };
+    }
+}
+exports.EvidenceExtractor = EvidenceExtractor;

package/dist/extraction/classifyCapture.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.classifyCaptureEnabled = classifyCaptureEnabled;
+exports.planCapture = planCapture;
+/**
+ * What to do with a saved note, from the local-rules classifier only.
+ *
+ * RENOR_CLASSIFY_CAPTURE defaults OFF. Off means the live save path is unchanged: the note
+ * stays a raw note and nothing is classified. There is no model call, no new provider, and
+ * no API key. The local rules cannot honestly name a subject, predicate and object, so even
+ * when the flag is on this module only returns a draft. It does not write a fact.
+ */
+const decision_model_1 = require("./decision-model");
+const DURABLE = new Set(['decision', 'preference', 'fact', 'result']);
+function classifyCaptureEnabled(env = process.env) {
+    const raw = (env.RENOR_CLASSIFY_CAPTURE ?? '').trim().toLowerCase();
+    return raw === '1' || raw === 'true' || raw === 'yes' || raw === 'on';
+}
+/** A draft only. `author` is the connection name plus "-auto", and nothing is written. */
+function planCapture(text, author, env = process.env) {
+    if (!classifyCaptureEnabled(env))
+        return { disposition: 'off' };
+    const kind = (0, decision_model_1.classifyNote)(text);
+    if (kind === 'sensitive')
+        return { disposition: 'drop', kind };
+    if (!DURABLE.has(kind))
+        return { disposition: 'raw', kind: kind === 'request' ? 'request' : 'noise' };
+    return {
+        disposition: 'structured',
+        kind: kind,
+        statement: text.trim(),
+        author: `${author}-auto`,
+    };
+}

package/dist/extraction/decision-model.js

@@ -0,0 +1,174 @@
+"use strict";
+/**
+ * DecisionModel adapter (Lane Jev write-path plan §3): the single seam for
+ * extraction-time typed decisions — capture-gate classification and dedupe
+ * adjudication. The ledger never depends on a vendor: the default TODAY is the
+ * deterministic local-rules implementation (`LocalRulesDecisionModel`, zero
+ * model calls, zero cost); a model-backed adapter (gemma4:31b, jev, ...) plugs
+ * in later by implementing this interface. No vendor is hardcoded anywhere in
+ * the write path.
+ *
+ * Contract shape (docs/evals/LANE-JEV-WRITE-PATH.md §3):
+ *   decide(task, input) -> { decision: TypedEnum, confidence, latencyMs, costUSDCents }
+ *
+ * Privacy mode is part of the interface: the local implementation never sends
+ * text off-host, and costUSDCents is 0 for every local decision.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalRulesDecisionModel = exports.STATIVE_CUE_RE = exports.NUMERIC_FACT_RE = void 0;
+exports.classifyNote = classifyNote;
+exports.defaultDecisionModel = defaultDecisionModel;
+const secretScanner_1 = require("./secretScanner");
+const rowStore_1 = require("../context/rowStore");
+/**
+ * Lexical identity normalization for the dedupe verdict, shared with the
+ * rowStore dedupe key — this must be the SAME function the key is built from.
+ * It used to be a byte-copy of `normDedupeValue`, which is how it drifted into
+ * deleting every non-Latin character independently of the key pipeline; the two
+ * are now one import so a key and its adjudication verdict cannot disagree.
+ */
+const norm = rowStore_1.normDedupeValue;
+/**
+ * v1 numeric-fact capture cues: a number (with optional unit) anchored to a
+ * stative or eventive predicate. Conservative and gold-blind — the rules are
+ * the current-baseline classification, not a quality claim (the Lane Jev
+ * adapter is the seam where a stronger classifier plugs in). Exported so the
+ * capture-gate rules and the candidate extractor share one definition.
+ */
+exports.NUMERIC_FACT_RE = /\b(\d+:\d{2}(?::\d{2})?|\d+(?:[.,]\d+)?)\s*(km|kg|mi|miles?|minutes?|mins?|hours?|hrs?|days?|weeks?|years?|%|percent|dollars?|usd|\$|€|£|reps?|lbs?|pounds?)?\b/i;
+exports.STATIVE_CUE_RE = /\b(is|are|was|were|has|have|had|weighs?|costs?|paid|earned|runs?|ran|completed|finished|measures?|lasted|took|scored|deadline|birthday|anniversary|scheduled|due)\b/i;
+/**
+ * Local rules DecisionModel — the default TODAY. Deterministic (same input →
+ * same decision), zero network, zero cost. Capture gate: a span is offered to
+ * fact extraction only when it carries a numeric value anchored by a cue
+ * verb/phrase; everything else gates to `none` in v1 (events/preferences are
+ * C3/C4 lanes). Dedupe: exact normalized (value, object) equality is
+ * `identical`; same object with a changed value is `updated`; otherwise
+ * `distinct`. Supersede is identity-keyed only — never blanket newest-wins
+ * (N18 KILL).
+ *
+ * Harmonization: the same adjudication semantics generalize per lane on the
+ * lane's own payload identity — event: same event + same `when` is
+ * `identical`, same event with a changed `when` is `updated`; preference:
+ * same normalized statement is `identical` (statement IS the identity),
+ * anything else `distinct`. The rowKind default keeps the v1 fact-lane
+ * callers (and their tests) byte-identical.
+ */
+const DECISION_RE = /\b(decided|decision|we will|we'll|going with|chose|chosen|the call is|agreed to)\b/i;
+const PREFERENCE_RE = /\b(prefer|preference|rather|always use|never use|don't use|do not use|instead of)\b/i;
+const RESULT_RE = /\b(passed|failed|shipped|the result|finished|deployed|merged)\b/i;
+const REQUEST_RE = /\b(please|can you|could you|would you|need you to|let me know|ask [a-z0-9_-]+ to)\b/i;
+const NOISE_LEAD_RE = /^(ok|okay|thanks|thank you|lol|hey|on it|looking|got it|sure|yep|nope)\b/i;
+const NOISE_CHATTER_RE = /\b(thanks|thank you|lol)\b/i;
+const COPULA_RE = /\b(is|are|was|were)\b/i;
+/**
+ * Cue order is fixed: a decision, preference or result is named before a question mark can
+ * steal it, and a numeric fact (the existing capture gate) is named before a broad "is".
+ * Anything else is noise. Sensitive text is refused before any of those.
+ */
+function classifyNote(text) {
+    const trimmed = text.trim();
+    if (!trimmed)
+        return 'noise';
+    if ((0, secretScanner_1.scanSecrets)(trimmed))
+        return 'sensitive';
+    if (DECISION_RE.test(trimmed))
+        return 'decision';
+    if (PREFERENCE_RE.test(trimmed))
+        return 'preference';
+    if (RESULT_RE.test(trimmed))
+        return 'result';
+    if (LocalRulesDecisionModel.captureGate(trimmed) === 'fact')
+        return 'fact';
+    if (REQUEST_RE.test(trimmed) || /\?\s*$/.test(trimmed))
+        return 'request';
+    if (NOISE_LEAD_RE.test(trimmed) || NOISE_CHATTER_RE.test(trimmed))
+        return 'noise';
+    const words = trimmed.split(/\s+/).length;
+    if (COPULA_RE.test(trimmed) && words >= 4)
+        return 'fact';
+    return 'noise';
+}
+class LocalRulesDecisionModel {
+    async decide(request) {
+        const start = Date.now();
+        let result;
+        if (request.task === 'capture_gate') {
+            result = {
+                task: 'capture_gate',
+                decision: LocalRulesDecisionModel.captureGate(request.text),
+                confidence: 1,
+                latencyMs: 0,
+                costUSDCents: 0,
+            };
+        }
+        else if (request.task === 'classify_capture') {
+            result = {
+                task: 'classify_capture',
+                decision: LocalRulesDecisionModel.classifyNote(request.text),
+                confidence: 1,
+                latencyMs: 0,
+                costUSDCents: 0,
+            };
+        }
+        else {
+            result = {
+                task: 'dedupe_adjudication',
+                decision: LocalRulesDecisionModel.adjudicate(request.candidate, request.existing, request.rowKind ?? 'fact'),
+                confidence: 1,
+                latencyMs: 0,
+                costUSDCents: 0,
+            };
+        }
+        // latencyMs is reported (measured wall time), never simulated.
+        const latencyMs = Date.now() - start;
+        return { ...result, latencyMs };
+    }
+    static captureGate(text) {
+        if (!text || !text.trim())
+            return 'none';
+        const hasValue = exports.NUMERIC_FACT_RE.test(text);
+        const hasCue = exports.STATIVE_CUE_RE.test(text);
+        if (hasValue && hasCue)
+            return 'fact';
+        return 'none';
+    }
+    /**
+     * Local rules for a saved note. Same constraints as the rest of this class: deterministic,
+     * no network, no key, cost 0. This is not a model. It does not invent a subject, predicate
+     * or object, and nothing here writes a memory.
+     */
+    static classifyNote(text) {
+        return classifyNote(text);
+    }
+    static adjudicate(candidate, existing, rowKind = 'fact') {
+        if (!existing)
+            return 'distinct';
+        if (rowKind === 'event') {
+            const c = candidate;
+            const e = existing;
+            if (norm(c.event) !== norm(e.event))
+                return 'distinct';
+            return norm(c.when) === norm(e.when) ? 'identical' : 'updated';
+        }
+        if (rowKind === 'preference') {
+            const c = candidate;
+            const e = existing;
+            return norm(c.statement) === norm(e.statement) ? 'identical' : 'distinct';
+        }
+        const c = candidate;
+        const e = existing;
+        const sameObject = norm(c.object) === norm(e.object);
+        const sameValue = norm(c.value) === norm(e.value);
+        if (sameObject && sameValue)
+            return 'identical';
+        if (sameObject && !sameValue)
+            return 'updated';
+        return 'distinct';
+    }
+}
+exports.LocalRulesDecisionModel = LocalRulesDecisionModel;
+/** The write path's default decision point — local rules today, vendor later. */
+function defaultDecisionModel() {
+    return new LocalRulesDecisionModel();
+}