@jmtrin/kevin-core 1.3.0

package/dist/CausalChain.js

@@ -0,0 +1,197 @@
+import { extractFixArgs, } from "./LessonFixer.js";
+import { hasColumn } from "./columns.js";
+import { toMs } from "./time-ms.js";
+/** K3-007 — a success only links to a failure within this many calls. */
+const MAX_LINK_DISTANCE = 10;
+export class CausalChain {
+    store;
+    memoryService;
+    metrics;
+    enrichFn;
+    constructor(store, memoryService, metrics, 
+    // v0.4.0 (K4-015) — opt-in promotion-time LLM phrasing. Absent in
+    // production (zero network calls by default); injected by tests or
+    // by a future settings-driven wiring.
+    enrichFn) {
+        this.store = store;
+        this.memoryService = memoryService;
+        this.metrics = metrics;
+        this.enrichFn = enrichFn;
+    }
+    // K3-007: link a success to the failing fingerprint only when it
+    // occurred within MAX_LINK_DISTANCE tool calls of the failure (plan
+    // §K3-007 acceptance: "within 24h and within 10 tool calls").
+    // v0.3.0 fix (bug #3) — the old code linked the most recent session
+    // success to the most recent unlinked error memory regardless of
+    // distance, so an unrelated success (e.g. an `ls` run after a
+    // typecheck failure) was stamped as the fix for that error.
+    onSuccess(_tool, _args, _projectId, sessionId) {
+        // v1.1.0 (K11-004 / plan §5.2, D11-01/D11-07) — ms-aware window: prefer _ms
+        const hasTsMs = hasColumn(this.store, "tool_calls", "ts_ms");
+        const successRow = (hasTsMs
+            ? this.store.prepare(`SELECT rowid, tool, args_summary, ts, ts_ms FROM tool_calls
+						 WHERE session_id = ? AND success = 1
+						 ORDER BY rowid DESC LIMIT 1`)
+            : this.store.prepare(`SELECT rowid, tool, args_summary, ts FROM tool_calls
+						 WHERE session_id = ? AND success = 1
+						 ORDER BY rowid DESC LIMIT 1`)).get(sessionId);
+        if (!successRow)
+            return;
+        const linkedFps = new Set(this.store
+            .prepare(`SELECT DISTINCT fix_for_fingerprint FROM tool_calls
+						 WHERE session_id = ? AND fix_for_fingerprint IS NOT NULL`)
+            .all(sessionId).map((r) => r.fix_for_fingerprint));
+        // Most recent failing calls in this session, newest first. The
+        // failing call's `error_fingerprint` (stamped by Reflector via
+        // onLinkError) is the SAME identity dimension the error memory
+        // uses; `fingerprint` is the legacy tool|args|success hash and
+        // simply never matches a reflector error memory.
+        const failRows = (hasTsMs
+            ? this.store.prepare(`SELECT rowid, COALESCE(error_fingerprint, fingerprint) AS fp, ts, ts_ms
+						 FROM tool_calls
+						 WHERE session_id = ?
+						   AND success = 0
+						   AND (error_fingerprint IS NOT NULL OR fingerprint IS NOT NULL)
+						 ORDER BY rowid DESC LIMIT ?`)
+            : this.store.prepare(`SELECT rowid, COALESCE(error_fingerprint, fingerprint) AS fp, ts
+						 FROM tool_calls
+						 WHERE session_id = ?
+						   AND success = 0
+						   AND (error_fingerprint IS NOT NULL OR fingerprint IS NOT NULL)
+						 ORDER BY rowid DESC LIMIT ?`)).all(sessionId, MAX_LINK_DISTANCE);
+        for (const fail of failRows) {
+            if (!fail.fp || linkedFps.has(fail.fp))
+                continue;
+            const dist = successRow.rowid - fail.rowid;
+            if (dist <= 0 || dist > MAX_LINK_DISTANCE)
+                continue;
+            // v1.1.0 — ≤24h window uses ms when available
+            const successMs = toMs(successRow.ts, successRow.ts_ms ?? null);
+            const failMs = toMs(fail.ts, fail.ts_ms ?? null);
+            if (successMs !== null && failMs !== null) {
+                const diff = successMs - failMs;
+                if (diff < 0 || diff > 86_400_000)
+                    continue;
+            }
+            const mem = this.store
+                .prepare(`SELECT 1 FROM memories
+					 WHERE fingerprint = ? AND type = 'error'
+					   AND origin = 'reflector' AND status IN ('active', 'stale')
+					   AND created_at > datetime('now', '-24 hours')
+					 LIMIT 1`)
+                .get(fail.fp);
+            if (!mem)
+                continue;
+            this.store
+                .prepare("UPDATE tool_calls SET fix_for_fingerprint = ? WHERE rowid = ?")
+                .run(fail.fp, successRow.rowid);
+            // v0.4.0 (K4-014) — deterministic "Fixed by:" raw material
+            // (plan §5.4 / D4-07): copy the linked success call's
+            // args_summary into memories.fix_args for every active row of
+            // that fingerprint (error + pattern), zero LLM cost.
+            const fixArgs = extractFixArgs({
+                tool: successRow.tool,
+                args_summary: successRow.args_summary ?? null,
+            });
+            if (fixArgs) {
+                this.store
+                    .prepare(`UPDATE memories SET fix_args = ?
+						 WHERE fingerprint = ? AND status IN ('active', 'stale')`)
+                    .run(fixArgs, fail.fp);
+            }
+            this.metrics?.incr("causal_links", 1);
+            return;
+        }
+    }
+    async onSessionIdle(sessionId) {
+        const linkedErrors = this.store
+            .prepare(`SELECT m.id, m.fingerprint, m.recurrence_count,
+				        (SELECT COUNT(*)
+				         FROM tool_calls tc_all
+				         WHERE tc_all.fix_for_fingerprint = m.fingerprint) as evidence_count
+				 FROM memories m
+				 WHERE m.type = 'error'
+				   AND m.origin = 'reflector'
+				   AND m.fingerprint IN (
+				       SELECT DISTINCT fix_for_fingerprint
+				       FROM tool_calls
+				       WHERE session_id = ? AND fix_for_fingerprint IS NOT NULL
+				   )
+				   AND m.status IN ('active', 'stale')
+				 GROUP BY m.fingerprint
+				 HAVING (
+				     SELECT MAX(tc.ts) FROM tool_calls tc
+				     WHERE tc.fix_for_fingerprint = m.fingerprint
+				 ) >= COALESCE(
+				     (SELECT MAX(m2.updated_at) FROM memories m2
+				      WHERE m2.fingerprint = m.fingerprint
+				        AND m2.type = 'pattern'
+				        AND m2.origin = 'causal'),
+				     '1970-01-01'
+				 )`)
+            .all(sessionId);
+        let promoted = 0;
+        for (const err of linkedErrors) {
+            try {
+                const result = this.memoryService.promoteToPattern(err.id, err.evidence_count, err.recurrence_count ?? 0);
+                if (result) {
+                    promoted++;
+                    // v0.4.0 (K4-009) — only a NEW pattern row counts as a
+                    // promotion; the idempotent refresh path no longer
+                    // inflates the metric. `patterns_causal` is deprecated
+                    // (key kept for compat, never incremented).
+                    if (result.created) {
+                        this.metrics?.incr("patterns_promoted_new", 1);
+                        // v0.4.0 (K4-015) — promotion-time LLM enrichment:
+                        // at most one call per NEW pattern, gated on
+                        // `kevin_settings.llm_reflection_enabled` and the
+                        // per-pattern `metadata.enriched` marker. Never on
+                        // the failure hot path.
+                        await this.enrichIfEnabled(err.id, result.id);
+                    }
+                }
+            }
+            catch {
+                // promoteToPattern may fail if the error memory was removed
+            }
+        }
+        return promoted;
+    }
+    /**
+     * v0.4.0 (K4-015) — fire the opt-in enrich hook at most once per
+     * promoted pattern. The hook's one-line phrase replaces the
+     * deterministic `Fixed by:` line; null keeps it. A call (phrase or
+     * not) stamps `metadata.enriched` so repeated idle cycles stay at
+     * one LLM call per pattern.
+     */
+    async enrichIfEnabled(errorId, patternId) {
+        if (!this.enrichFn || !this.isLlmReflectionEnabled())
+            return;
+        const pattern = this.memoryService.getById(patternId);
+        if (!pattern)
+            return;
+        const meta = (pattern.metadata ?? {});
+        if (meta.enriched === true)
+            return;
+        const phrase = await this.enrichFn({
+            lesson: pattern.content,
+            fixArgs: pattern.fixArgs ?? null,
+            originalError: this.memoryService.getById(errorId)?.content ?? null,
+        });
+        const content = phrase
+            ? pattern.content.includes("\nFixed by: ")
+                ? pattern.content.replace(/\nFixed by: .+$/s, `\n${phrase}`)
+                : `${pattern.content}\n${phrase}`
+            : pattern.content;
+        this.memoryService.update(patternId, {
+            content,
+            metadata: { ...meta, enriched: true },
+        });
+    }
+    isLlmReflectionEnabled() {
+        const row = this.store
+            .prepare("SELECT value FROM kevin_settings WHERE key = ?")
+            .get("llm_reflection_enabled");
+        return row?.value === "1";
+    }
+}

package/dist/ChatBridge.d.ts

@@ -0,0 +1,41 @@
+import { type PendingProposal } from "./TuiActions.js";
+export type BridgeDeps = {
+    readonly getPending: () => readonly PendingProposal[];
+    readonly approve: (proposalId: string) => unknown;
+    readonly reject: (proposalId: string, note?: string) => unknown;
+    readonly acknowledge: (conflictId: string) => unknown;
+    readonly metrics?: {
+        incr: (key: "tui_actions_invoked", by?: number) => void;
+    } | null;
+};
+export type ParsedBridgeCommand = {
+    readonly type: "approve";
+    readonly proposalId: string;
+    readonly token: string;
+    readonly note?: string;
+} | {
+    readonly type: "reject";
+    readonly proposalId: string;
+    readonly token: string;
+    readonly note?: string;
+} | {
+    readonly type: "ack";
+    readonly conflictId: string;
+};
+export declare function parseBridgeCommand(text: string): ParsedBridgeCommand | null;
+export declare const KEVIN_COMMAND_RE: RegExp;
+export interface BridgeResult {
+    readonly handled: boolean;
+    readonly status?: "applied" | "rejected" | "stale_skipped" | "error";
+    readonly detail?: string;
+}
+/**
+ * Execute a chat message through the bridge.
+ * - Non-matching → {handled:false} (byte-identical pass-through)
+ * - Matching but stale/invalid → {handled:false, status:"stale_skipped"} (pass-through + counter)
+ * - Valid → executes via deps handlers, {handled:true}
+ *
+ * Valid commands are SWALLOWED — caller must not forward to model.
+ * Invalid/stale commands pass through untouched (D12-09).
+ */
+export declare function handleBridgeCommand(text: string, deps: BridgeDeps): BridgeResult;

package/dist/ChatBridge.js

@@ -0,0 +1,103 @@
+// v1.2.0 (K12-018 / plan §4.4 R3, D12-09) — chat-command bridge (universal actions).
+// Hot path: ONE regex test on non-match, allocation-free.
+import { verifyFresh, } from "./TuiActions.js";
+// Exact regex for approve/reject (require 16-hex token, optional note capture).
+// Ack variant is token-free (acknowledge is non-destructive, matches mailbox).
+const APPROVE_REJECT_RE = /^\/kevin-(approve|reject)\s+(\S+)\s+([0-9a-f]{16})(?:\s+([\s\S]+))?$/;
+const ACK_RE = /^\/kevin-ack\s+(\S+)\s*$/;
+// Combined pattern for documentation / static analysis (covers both forms).
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const _DOC_RE = /^\/kevin-(approve|reject|ack)\s+(\S+)\s+([0-9a-f]{16})(?:\s+([\s\S]+))?$/;
+export function parseBridgeCommand(text) {
+    // Approve / reject — require token
+    const m = APPROVE_REJECT_RE.exec(text);
+    if (m) {
+        const type = m[1];
+        const proposalId = m[2];
+        const token = m[3];
+        const note = m[4] !== undefined ? m[4] : undefined;
+        if (type === "approve")
+            return {
+                type: "approve",
+                proposalId,
+                token,
+                ...(note !== undefined ? { note } : {}),
+            };
+        return {
+            type: "reject",
+            proposalId,
+            token,
+            ...(note !== undefined ? { note } : {}),
+        };
+    }
+    const ack = ACK_RE.exec(text);
+    if (ack) {
+        return { type: "ack", conflictId: ack[1] };
+    }
+    return null;
+}
+// Backward alias for tests that import by plan name
+export const KEVIN_COMMAND_RE = APPROVE_REJECT_RE;
+/**
+ * Execute a chat message through the bridge.
+ * - Non-matching → {handled:false} (byte-identical pass-through)
+ * - Matching but stale/invalid → {handled:false, status:"stale_skipped"} (pass-through + counter)
+ * - Valid → executes via deps handlers, {handled:true}
+ *
+ * Valid commands are SWALLOWED — caller must not forward to model.
+ * Invalid/stale commands pass through untouched (D12-09).
+ */
+export function handleBridgeCommand(text, deps) {
+    const parsed = parseBridgeCommand(text);
+    if (!parsed)
+        return { handled: false };
+    if (parsed.type === "ack") {
+        // Ack is non-destructive, no token verification — matches mailbox acknowledge semantics.
+        try {
+            deps.acknowledge(parsed.conflictId);
+            try {
+                deps.metrics?.incr("tui_actions_invoked", 1);
+            }
+            catch { }
+            return { handled: true, status: "applied" };
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            return { handled: true, status: "error", detail: msg };
+        }
+    }
+    // approve / reject — verify token against CURRENT pending state (same as mailbox)
+    const pending = deps.getPending();
+    const action = {
+        type: parsed.type,
+        proposalId: parsed.proposalId,
+        token: parsed.token,
+        ...(parsed.note !== undefined ? { note: parsed.note } : {}),
+    };
+    const fresh = verifyFresh(action, pending);
+    if (!fresh.ok) {
+        // Invalid/stale → pass-through untouched (do NOT swallow). Caller should forward byte-identically.
+        // Audit counter could be incremented here, but not as contract metric (blockedSnapshot-style internal).
+        return { handled: false, status: "stale_skipped", detail: fresh.reason };
+    }
+    try {
+        if (parsed.type === "approve") {
+            deps.approve(parsed.proposalId);
+            try {
+                deps.metrics?.incr("tui_actions_invoked", 1);
+            }
+            catch { }
+            return { handled: true, status: "applied" };
+        }
+        deps.reject(parsed.proposalId, parsed.note);
+        try {
+            deps.metrics?.incr("tui_actions_invoked", 1);
+        }
+        catch { }
+        return { handled: true, status: "rejected" };
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return { handled: true, status: "error", detail: msg };
+    }
+}

package/dist/ConflictDetector.d.ts

@@ -0,0 +1,35 @@
+import type { MemoryService } from "./MemoryService.js";
+import type { RepoTruth } from "./RepoTruth.js";
+import type { Store } from "./Store.js";
+import type { Metrics } from "./metrics.js";
+export type ConflictKind = "repo_truth" | "decision_pair" | "temporal";
+export interface Conflict {
+    readonly id: string;
+    readonly kind: ConflictKind;
+    readonly memoryA: string;
+    readonly memoryB?: string;
+    readonly factId?: string;
+    readonly detail: string;
+}
+export interface RepoTruthConflictInput {
+    readonly memoryId: string;
+    readonly factId?: string | null;
+    readonly reasons: readonly string[];
+}
+export declare class ConflictDetector {
+    private readonly store;
+    private readonly projectId;
+    private readonly repoTruth?;
+    private readonly memoryService?;
+    private readonly metrics;
+    constructor(store: Store, projectId: string, metrics?: Metrics | null, repoTruth?: RepoTruth | undefined, memoryService?: MemoryService | undefined);
+    detect(repoTruthInput?: readonly RepoTruthConflictInput[]): Conflict[];
+    acknowledge(id: string): void;
+    /** Human-only operation. It resolves the conflict row, never a memory. */
+    resolve(id: string, keepMemoryId: string): void;
+    private detectRepoTruth;
+    private repoTruthInputs;
+    private detectDecisionPairs;
+    private detectTemporal;
+    private insertIfNew;
+}

package/dist/ConflictDetector.js

@@ -0,0 +1,260 @@
+import { mapRow } from "./MemoryService.js";
+import { normalize } from "./fingerprint.js";
+import { STOP_WORDS } from "./query-tokenizer.js";
+import { uuidv7 } from "./uuid.js";
+const POLARITY_RULES = [
+    {
+        positive: ["use"],
+        negative: [
+            ["do", "not", "use"],
+            ["don't", "use"],
+            ["never", "use"],
+        ],
+    },
+    { positive: ["always"], negative: [["never"]] },
+    { positive: ["required"], negative: [["forbidden"], ["not", "required"]] },
+    { positive: ["enable"], negative: [["disable"]] },
+    { positive: ["prefer"], negative: [["avoid"]] },
+];
+const POLARITY_WORDS = new Set([
+    "use",
+    "do",
+    "not",
+    // "don't" tokenizes to ["don", "t"] (see tokens()); the lexicon phrase
+    // ["don't","use"] is matched by tokenizing the phrase the same way, so
+    // both fragments must be excluded from subjects() too (K7-014).
+    "don",
+    "t",
+    "never",
+    "always",
+    "required",
+    "forbidden",
+    "enable",
+    "disable",
+    "prefer",
+    "avoid",
+]);
+export class ConflictDetector {
+    store;
+    projectId;
+    repoTruth;
+    memoryService;
+    metrics;
+    constructor(store, projectId, metrics, repoTruth, memoryService) {
+        this.store = store;
+        this.projectId = projectId;
+        this.repoTruth = repoTruth;
+        this.memoryService = memoryService;
+        this.metrics = metrics ?? null;
+    }
+    detect(repoTruthInput) {
+        const detected = [];
+        detected.push(...this.detectRepoTruth(repoTruthInput));
+        detected.push(...this.detectDecisionPairs());
+        detected.push(...this.detectTemporal());
+        return detected;
+    }
+    acknowledge(id) {
+        this.store
+            .prepare("UPDATE memory_conflicts SET status = 'acknowledged' WHERE id = ? AND project_id = ? AND status = 'open'")
+            .run(id, this.projectId);
+    }
+    /** Human-only operation. It resolves the conflict row, never a memory. */
+    resolve(id, keepMemoryId) {
+        const row = this.store
+            .prepare(`SELECT memory_a, memory_b FROM memory_conflicts
+				 WHERE id = ? AND project_id = ? AND status <> 'resolved'`)
+            .get(id, this.projectId);
+        if (!row)
+            throw new Error(`conflict not found: ${id}`);
+        if (keepMemoryId !== row.memory_a && keepMemoryId !== row.memory_b) {
+            throw new Error("keep must identify one of the conflict memories");
+        }
+        this.store
+            .prepare("UPDATE memory_conflicts SET status = 'resolved', resolved_at = datetime('now') WHERE id = ? AND project_id = ?")
+            .run(id, this.projectId);
+    }
+    detectRepoTruth(input) {
+        const items = input ?? this.repoTruthInputs();
+        const out = [];
+        for (const item of items) {
+            for (const reason of item.reasons) {
+                this.memoryService?.applyTruthPenalty(item.memoryId, 0.5, reason);
+                const id = this.insertIfNew({
+                    kind: "repo_truth",
+                    memoryA: item.memoryId,
+                    memoryB: null,
+                    factId: item.factId ?? null,
+                    detail: reason,
+                });
+                if (id)
+                    out.push({
+                        id,
+                        kind: "repo_truth",
+                        memoryA: item.memoryId,
+                        factId: item.factId ?? undefined,
+                        detail: reason,
+                    });
+            }
+        }
+        // v0.7.0 (D7-03) — "recoverable by re-scanning": a memory whose
+        // contradiction has lapsed (the repo no longer contradicts it) is
+        // de-ranked no longer. The conflict row stays open — resolution is
+        // human-initiated only (D7-06) — but the score penalty lifts, so
+        // fixing the repo genuinely recovers the memory. Runs only on the
+        // production path (no explicit input): explicit-input callers control
+        // every write themselves.
+        if (!input && this.repoTruth && this.memoryService) {
+            const penalized = this.store
+                .prepare("SELECT id FROM memories WHERE project_id = ? AND truth_penalty > 0 AND status = 'active'")
+                .all(this.projectId);
+            for (const row of penalized) {
+                const memory = this.memoryService.getById(row.id);
+                if (!memory)
+                    continue;
+                if ((this.repoTruth.contradictions(memory) ?? []).length === 0) {
+                    this.memoryService.applyTruthPenalty(row.id, 0, "");
+                }
+            }
+        }
+        return out;
+    }
+    repoTruthInputs() {
+        if (!this.repoTruth)
+            return [];
+        const rows = this.store
+            .prepare(`SELECT id, type, content, scope, relevance_score, source_tool,
+				 source_session, metadata, created_at, updated_at, expires_at,
+				 project_id, fingerprint, origin, evidence_count, last_verified_at,
+				 status, fix_args, ignored, superseded_by, feedback_positive,
+				 feedback_negative, curated, curated_at, inferable,
+				 truth_penalty, contradicted_at
+				 FROM memories WHERE project_id = ? AND status = 'active'`)
+            .all(this.projectId);
+        return rows.flatMap((row) => {
+            // v1.1.0 (K11-014) — route through mapRow so metadata is parsed and confidence derived
+            const memory = mapRow(row);
+            const reasons = this.repoTruth?.contradictions(memory) ?? [];
+            return reasons.length > 0
+                ? [{ memoryId: row.id, reasons }]
+                : [];
+        });
+    }
+    detectDecisionPairs() {
+        const rows = this.store
+            .prepare(`SELECT id, type, content, fingerprint FROM memories
+				 WHERE project_id = ? AND status = 'active'
+				 AND type IN ('decision', 'rule') ORDER BY id`)
+            .all(this.projectId);
+        const out = [];
+        for (let i = 0; i < rows.length; i++) {
+            for (let j = i + 1; j < rows.length; j++) {
+                const a = rows[i];
+                const b = rows[j];
+                if (!a || !b || a.fingerprint === b.fingerprint)
+                    continue;
+                const pair = oppositePair(a.content, b.content);
+                if (!pair)
+                    continue;
+                const id = this.insertIfNew({
+                    kind: "decision_pair",
+                    memoryA: a.id,
+                    memoryB: b.id,
+                    factId: null,
+                    detail: pair,
+                });
+                if (id)
+                    out.push({
+                        id,
+                        kind: "decision_pair",
+                        memoryA: a.id,
+                        memoryB: b.id,
+                        detail: pair,
+                    });
+            }
+        }
+        return out;
+    }
+    detectTemporal() {
+        const rows = this.store
+            .prepare(`SELECT m.id,
+				 MAX(CASE WHEN i.outcome = 'effective' THEN i.injected_at END) AS effective_at,
+				 MAX(CASE WHEN i.outcome = 'ineffective' THEN i.injected_at END) AS ineffective_at
+				 FROM memories m JOIN kevin_injections i ON i.memory_id = m.id
+				 WHERE m.project_id = ? AND m.status = 'active'
+				 GROUP BY m.id
+				 HAVING effective_at IS NOT NULL AND ineffective_at IS NOT NULL
+				 AND ineffective_at > effective_at`)
+            .all(this.projectId);
+        const out = [];
+        for (const row of rows) {
+            const detail = `memory was effective at ${row.effective_at} and became ineffective at ${row.ineffective_at}`;
+            const id = this.insertIfNew({
+                kind: "temporal",
+                memoryA: row.id,
+                memoryB: null,
+                factId: null,
+                detail,
+            });
+            if (id)
+                out.push({ id, kind: "temporal", memoryA: row.id, detail });
+        }
+        return out;
+    }
+    insertIfNew(input) {
+        const existing = this.store
+            .prepare(`SELECT id FROM memory_conflicts
+				 WHERE project_id = ? AND kind = ? AND memory_a = ?
+				 AND (memory_b IS ? OR (memory_b IS NULL AND ? IS NULL))
+				 AND (fact_id IS ? OR (fact_id IS NULL AND ? IS NULL))
+				 AND status = 'open' LIMIT 1`)
+            .get(this.projectId, input.kind, input.memoryA, input.memoryB, input.memoryB, input.factId, input.factId);
+        if (existing)
+            return null;
+        const id = uuidv7();
+        this.store
+            .prepare(`INSERT INTO memory_conflicts
+				 (id, project_id, memory_a, memory_b, fact_id, kind, detail)
+				 VALUES (?, ?, ?, ?, ?, ?, ?)`)
+            .run(id, this.projectId, input.memoryA, input.memoryB, input.factId, input.kind, input.detail);
+        this.metrics?.incr("conflicts_detected", 1);
+        return id;
+    }
+}
+function tokens(text) {
+    return normalize(text).match(/[a-z0-9@._/-]+/g) ?? [];
+}
+function hasPhrase(words, phrase) {
+    if (phrase.length === 1)
+        return words.includes(phrase[0] ?? "");
+    for (let i = 0; i <= words.length - phrase.length; i++) {
+        if (phrase.every((word, offset) => words[i + offset] === word))
+            return true;
+    }
+    return false;
+}
+function polarity(text, rule) {
+    const words = tokens(text);
+    // Lexicon phrases are run through the same tokenizer as the text: "don't
+    // use" → ["don","t","use"], which is exactly how the text's own apostrophe
+    // is split, so a phrase never becomes unreachable (K7-014).
+    const match = (phrase) => hasPhrase(words, tokens(phrase.join(" ")));
+    const negative = rule.negative.some(match);
+    return { positive: !negative && match(rule.positive), negative };
+}
+function subjects(text) {
+    return new Set(tokens(text).filter((token) => !STOP_WORDS.has(token) && !POLARITY_WORDS.has(token)));
+}
+function oppositePair(a, b) {
+    const shared = [...subjects(a)].some((token) => subjects(b).has(token));
+    if (!shared)
+        return null;
+    for (const rule of POLARITY_RULES) {
+        const pa = polarity(a, rule);
+        const pb = polarity(b, rule);
+        if ((pa.positive && pb.negative) || (pa.negative && pb.positive)) {
+            return `statements carry opposite ${rule.positive.join(" ")} polarity for shared subject ${shared}`;
+        }
+    }
+    return null;
+}