@tenphi/akno-core 0.1.0

package/dist/watch/watcher.js

@@ -0,0 +1,143 @@
+import fs from 'node:fs';
+import path from 'node:path';
+/**
+ * **FSEvents, not polling.** Node's recursive `fs.watch` uses FSEvents on
+ * macOS: native, cheap, and it reports renames as renames.
+ *
+ * But FSEvents coalesces under load and can drop events after a sleep/wake or a
+ * large sync, so a **periodic hash sweep is the backstop.** Watching alone is not
+ * a correctness guarantee; hashing is. At ~10ms for a typical knowledge base the
+ * sweep can run every few minutes and cost nothing.
+ */
+export class Watcher {
+    watcher = null;
+    sweepTimer = null;
+    verifyTimer = null;
+    debounceTimer = null;
+    pending = new Set();
+    running = false;
+    /** Set when a change arrived mid-index; guarantees one more pass after it. */
+    dirty = false;
+    #config;
+    #indexer;
+    #events;
+    constructor(config, indexer, events = {}) {
+        this.#config = config;
+        this.#indexer = indexer;
+        this.#events = events;
+    }
+    start() {
+        if (this.watcher)
+            return;
+        try {
+            this.watcher = fs.watch(this.#config.aknoPath, { recursive: true, persistent: true }, (_type, filename) => {
+                if (!filename) {
+                    // A null filename means FSEvents coalesced and cannot say what moved.
+                    // The only correct response is to treat the whole tree as suspect.
+                    this.dirty = true;
+                    this.schedule();
+                    return;
+                }
+                const relPath = filename.split(path.sep).join('/');
+                if (this.shouldIgnore(relPath))
+                    return;
+                this.pending.add(relPath);
+                this.schedule();
+            });
+            this.watcher.on('error', (error) => this.#events.onError?.(error));
+        }
+        catch (error) {
+            // A watch that cannot be established is not fatal: the sweep below still
+            // reconciles, just with more latency.
+            this.#events.onError?.(error);
+        }
+        if (this.#config.watch.sweepIntervalMs > 0) {
+            this.sweepTimer = setInterval(() => {
+                this.dirty = true;
+                void this.flush();
+            }, this.#config.watch.sweepIntervalMs);
+            this.sweepTimer.unref();
+        }
+        if (this.#config.watch.verifyIntervalMs > 0) {
+            // The correctness path: a full hash sweep that catches a sync client or a
+            // restored backup which preserved mtime across a real content change.
+            this.verifyTimer = setInterval(() => {
+                void this.flush({ verify: true });
+            }, this.#config.watch.verifyIntervalMs);
+            this.verifyTimer.unref();
+        }
+    }
+    /**
+     * The service reconciles on wake — the gap where a laptop was closed is
+     * exactly when the folder gets edited on another device. A host that knows about
+     * sleep/wake calls this; the periodic sweep covers the case where nothing does.
+     */
+    reconcileNow() {
+        this.dirty = true;
+        return this.flush({ verify: true });
+    }
+    async stop() {
+        this.watcher?.close();
+        this.watcher = null;
+        if (this.sweepTimer)
+            clearInterval(this.sweepTimer);
+        if (this.verifyTimer)
+            clearInterval(this.verifyTimer);
+        if (this.debounceTimer)
+            clearTimeout(this.debounceTimer);
+        this.sweepTimer = this.verifyTimer = this.debounceTimer = null;
+    }
+    shouldIgnore(relPath) {
+        const segments = relPath.split('/');
+        if (segments.some((segment) => segment.startsWith('.')))
+            return true;
+        if (segments.some((segment) => this.#config.ignore.includes(segment)))
+            return true;
+        // Editors and sync clients write to a temp name then rename. Indexing the
+        // temp file wastes a pass and briefly indexes a partial page.
+        const base = segments.at(-1) ?? '';
+        return /(^~|\.tmp$|\.swp$|\.crdownload$|\.part$|^\.#|~$)/.test(base);
+    }
+    schedule() {
+        if (this.debounceTimer)
+            clearTimeout(this.debounceTimer);
+        // FSEvents coalesces, but an editor still produces a write storm on save.
+        this.debounceTimer = setTimeout(() => void this.flush(), this.#config.watch.debounceMs);
+    }
+    async flush(options = {}) {
+        if (this.running) {
+            // A change that arrived while indexing must not be lost to the guard.
+            this.dirty = true;
+            return;
+        }
+        const changed = [...this.pending];
+        const wholeTree = this.dirty || options.verify;
+        if (changed.length === 0 && !wholeTree)
+            return;
+        this.pending.clear();
+        this.dirty = false;
+        this.running = true;
+        try {
+            const report = await this.#indexer.run({
+                ...(options.verify ? { verify: true } : {}),
+                // A targeted pass cannot conclude anything about deletions, so a
+                // coalesced or swept run deliberately walks the whole tree.
+                ...(wholeTree ? {} : { only: changed }),
+            });
+            this.#events.onIndexed?.(report, changed);
+            // After indexing, so an inbox handler sees a knowledge base that already knows
+            // about the file it is about to move.
+            if (this.#events.onArrival)
+                await this.#events.onArrival(changed);
+        }
+        catch (error) {
+            this.#events.onError?.(error);
+        }
+        finally {
+            this.running = false;
+            if (this.dirty || this.pending.size > 0)
+                this.schedule();
+        }
+    }
+}
+//# sourceMappingURL=watcher.js.map

package/dist/watch/watcher.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"watcher.js","sourceRoot":"","sources":["../../src/watch/watcher.ts"],"names":[],"mappings":"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"}

package/dist/write/atomic.d.ts

@@ -0,0 +1,34 @@
+import type { Store } from '../store/db.ts';
+/**
+ * Every byte Akno writes into the knowledge base goes through here.
+ *
+ * Two properties, both of which matter more than they look:
+ *
+ * **Atomic.** Write a sibling temp file, fsync it, rename over the target. A
+ * rename within one APFS directory is atomic, so a reader — the watcher, an
+ * editor, a sync client, `recall` reading lines off disk — never sees a half-
+ * written page. Writing in place would let a crash or a concurrent read catch a
+ * truncated file, and the truncated version is what gets indexed and cited.
+ *
+ * **Self-aware.** The resulting hash, size and mtime are recorded in `files`
+ * immediately, so the watcher recognises Akno's own write and does not schedule
+ * a re-index of a page it already has. That promise about the `id`
+ * write; it has to hold for every write or the watcher chases its own tail.
+ */
+export interface WriteResult {
+    relPath: string;
+    absPath: string;
+    /** Bytes before the write. Null when the file did not exist. */
+    before: string | null;
+    after: string;
+    created: boolean;
+}
+export declare function writeFileAtomic(aknoPath: string, relPath: string, content: string): Promise<WriteResult>;
+/**
+ * Records Akno's own write in `files` so the next sweep sees nothing changed.
+ * Called after the write and inside the same transaction as the journal entry.
+ */
+export declare function recordOwnWrite(store: Store, aknoPath: string, relPath: string, content: string, pageId: string | null): void;
+/** Restores a file to exact prior bytes, or removes it if there were none. */
+export declare function restoreFile(aknoPath: string, relPath: string, before: string | null): Promise<void>;
+//# sourceMappingURL=atomic.d.ts.map

package/dist/write/atomic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"atomic.d.ts","sourceRoot":"","sources":["../../src/write/atomic.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAC;AAE5C;;;;;;;;;;;;;;;GAeG;AAEH,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,gEAAgE;IAChE,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,OAAO,CAAC;CAClB;AAKD,wBAAsB,eAAe,CACnC,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,WAAW,CAAC,CAyBtB;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAC5B,KAAK,EAAE,KAAK,EACZ,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,MAAM,GAAG,IAAI,GACpB,IAAI,CAqBN;AAED,8EAA8E;AAC9E,wBAAsB,WAAW,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAMzG"}

package/dist/write/atomic.js

@@ -0,0 +1,58 @@
+import fs from 'node:fs';
+import fsp from 'node:fs/promises';
+import path from 'node:path';
+import { sha256 } from "../store/ids.js";
+/** The temp suffix the watcher already ignores, so a write never wakes it twice. */
+const TEMP_SUFFIX = '.akno.tmp';
+export async function writeFileAtomic(aknoPath, relPath, content) {
+    const absPath = path.join(aknoPath, relPath);
+    await fsp.mkdir(path.dirname(absPath), { recursive: true });
+    let before = null;
+    try {
+        before = await fsp.readFile(absPath, 'utf8');
+    }
+    catch (err) {
+        if (err.code !== 'ENOENT')
+            throw err;
+    }
+    const tempPath = `${absPath}${TEMP_SUFFIX}`;
+    const handle = await fsp.open(tempPath, 'w', 0o644);
+    try {
+        await handle.writeFile(content, 'utf8');
+        // Without the fsync the rename can land before the data does, and a crash in
+        // that window leaves a correctly-named empty file — the worst outcome, because
+        // it looks like a page the user emptied on purpose.
+        await handle.sync();
+    }
+    finally {
+        await handle.close();
+    }
+    await fsp.rename(tempPath, absPath);
+    return { relPath, absPath, before, after: content, created: before === null };
+}
+/**
+ * Records Akno's own write in `files` so the next sweep sees nothing changed.
+ * Called after the write and inside the same transaction as the journal entry.
+ */
+export function recordOwnWrite(store, aknoPath, relPath, content, pageId) {
+    // `bigint: true` to match the scanner exactly. A float mtime loses precision
+    // above ~2^53 ns, and a value that differs from what the scanner would read is
+    // worse than none — it defeats the stat fast path on every single sweep.
+    const stat = fs.statSync(path.join(aknoPath, relPath), { bigint: true, throwIfNoEntry: false });
+    store.db
+        .prepare(`INSERT INTO files(rel_path, size, mtime_ns, sha256, kind, page_id, indexed_at)
+       VALUES(?, ?, ?, ?, 'page', ?, ?)
+       ON CONFLICT(rel_path) DO UPDATE SET
+         size = excluded.size, mtime_ns = excluded.mtime_ns, sha256 = excluded.sha256,
+         page_id = excluded.page_id, indexed_at = excluded.indexed_at`)
+        .run(relPath, Buffer.byteLength(content, 'utf8'), stat ? String(stat.mtimeNs) : '0', sha256(content), pageId, new Date().toISOString());
+}
+/** Restores a file to exact prior bytes, or removes it if there were none. */
+export async function restoreFile(aknoPath, relPath, before) {
+    if (before === null) {
+        await fsp.rm(path.join(aknoPath, relPath), { force: true });
+        return;
+    }
+    await writeFileAtomic(aknoPath, relPath, before);
+}
+//# sourceMappingURL=atomic.js.map

package/dist/write/atomic.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"atomic.js","sourceRoot":"","sources":["../../src/write/atomic.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,SAAS,CAAC;AACzB,OAAO,GAAG,MAAM,kBAAkB,CAAC;AACnC,OAAO,IAAI,MAAM,WAAW,CAAC;AAC7B,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AA6BzC,oFAAoF;AACpF,MAAM,WAAW,GAAG,WAAW,CAAC;AAEhC,MAAM,CAAC,KAAK,UAAU,eAAe,CACnC,QAAgB,EAChB,OAAe,EACf,OAAe;IAEf,MAAM,OAAO,GAAG,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC;IAC7C,MAAM,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;IAE5D,IAAI,MAAM,GAAkB,IAAI,CAAC;IACjC,IAAI,CAAC;QACH,MAAM,GAAG,MAAM,GAAG,CAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;IAC/C,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,IAAK,GAA6B,CAAC,IAAI,KAAK,QAAQ;YAAE,MAAM,GAAG,CAAC;IAClE,CAAC;IAED,MAAM,QAAQ,GAAG,GAAG,OAAO,GAAG,WAAW,EAAE,CAAC;IAC5C,MAAM,MAAM,GAAG,MAAM,GAAG,CAAC,IAAI,CAAC,QAAQ,EAAE,GAAG,EAAE,KAAK,CAAC,CAAC;IACpD,IAAI,CAAC;QACH,MAAM,MAAM,CAAC,SAAS,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;QACxC,6EAA6E;QAC7E,+EAA+E;QAC/E,oDAAoD;QACpD,MAAM,MAAM,CAAC,IAAI,EAAE,CAAC;IACtB,CAAC;YAAS,CAAC;QACT,MAAM,MAAM,CAAC,KAAK,EAAE,CAAC;IACvB,CAAC;IACD,MAAM,GAAG,CAAC,MAAM,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC;IAEpC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,KAAK,IAAI,EAAE,CAAC;AAChF,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,cAAc,CAC5B,KAAY,EACZ,QAAgB,EAChB,OAAe,EACf,OAAe,EACf,MAAqB;IAErB,6EAA6E;IAC7E,+EAA+E;IAC/E,yEAAyE;IACzE,MAAM,IAAI,GAAG,EAAE,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,OAAO,CAAC,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,cAAc,EAAE,KAAK,EAAE,CAAC,CAAC;IAChG,KAAK,CAAC,EAAE;SACL,OAAO,CACN;;;;sEAIgE,CACjE;SACA,GAAG,CACF,OAAO,EACP,MAAM,CAAC,UAAU,CAAC,OAAO,EAAE,MAAM,CAAC,EAClC,IAAI,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,GAAG,EACjC,MAAM,CAAC,OAAO,CAAC,EACf,MAAM,EACN,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE,CACzB,CAAC;AACN,CAAC;AAED,8EAA8E;AAC9E,MAAM,CAAC,KAAK,UAAU,WAAW,CAAC,QAAgB,EAAE,OAAe,EAAE,MAAqB;IACxF,IAAI,MAAM,KAAK,IAAI,EAAE,CAAC;QACpB,MAAM,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,OAAO,CAAC,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;QAC5D,OAAO;IACT,CAAC;IACD,MAAM,eAAe,CAAC,QAAQ,EAAE,OAAO,EAAE,MAAM,CAAC,CAAC;AACnD,CAAC"}

package/dist/write/conflict.d.ts

@@ -0,0 +1,43 @@
+import type { ConflictReport } from '@tenphi/akno-protocol';
+import type { Store } from '../store/db.ts';
+/**
+ * Two values differ *meaningfully* when their comparable cores differ. Reached
+ * only for values that already contain a number or a decisive word, so this is
+ * about "€33 vs €33/month" (same) against "€33 vs €47" (different).
+ *
+ * Exported for the thorough pass, which joins facts across the whole knowledge base and
+ * has to decide "differ" exactly the way the inline check does. Two answers to that question
+ * would mean the cycle reporting conflicts a write would have allowed, or missing ones it
+ * would have blocked.
+ */
+export declare function valuesConflict(existing: string, incoming: string): boolean;
+export interface ConflictOptions {
+    store: Store;
+    pageId: string;
+    slug: string;
+    /** The page as it stands. Compared against, line for line. */
+    body: string;
+    /** Line number the body starts at, so a report addresses the real line. */
+    bodyStartLine: number;
+    /** The text being written. */
+    incoming: string;
+    /** Echo of a token the caller already resolved with the user. */
+    resolveToken?: string;
+}
+/**
+ * Returns the first genuine conflict, or null. First rather than all: a caller has
+ * to take this to the user, and one clear question beats a list.
+ *
+ * Both sides go through the **same extractor**, which is the whole trick. The first
+ * implementation compared a structurally-extracted attribute from the incoming text
+ * against the `attribute` a model had assigned to an existing fact — and those are
+ * different vocabularies. Appending `- Nights: 5` over an existing `- Nights: 3`
+ * produced no conflict at all, because the model had labelled the existing line's
+ * attribute `total` while the extractor read the new one as `nights`. Two names for
+ * the same thing never join.
+ *
+ * Comparing the page's own lines against the incoming lines also means conflict
+ * detection **works with no chat model at all**, which is what makes it cheap.
+ */
+export declare function detectConflict(options: ConflictOptions): ConflictReport | null;
+//# sourceMappingURL=conflict.d.ts.map

package/dist/write/conflict.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conflict.d.ts","sourceRoot":"","sources":["../../src/write/conflict.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAC5D,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAC;AAqE5C;;;;;;;;;GASG;AACH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAc1E;AAWD,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,KAAK,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,8DAA8D;IAC9D,IAAI,EAAE,MAAM,CAAC;IACb,2EAA2E;IAC3E,aAAa,EAAE,MAAM,CAAC;IACtB,8BAA8B;IAC9B,QAAQ,EAAE,MAAM,CAAC;IACjB,iEAAiE;IACjE,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,eAAe,GAAG,cAAc,GAAG,IAAI,CA0C9E"}

package/dist/write/conflict.js

@@ -0,0 +1,149 @@
+import { createHash } from 'node:crypto';
+/**
+ * **Cheap inline, thorough offline.**
+ *
+ * On every write: compare only against facts on the target page, flag only when
+ * two claims share a subject and attribute but differ in value, and bias toward
+ * numbers, dates, names and identifiers — where conflicts are real and detectable.
+ * Free prose rarely conflicts meaningfully, and a detector that thinks it does
+ * will block half of all writes.
+ *
+ * **When uncertain, write — do not block.** A false block costs a turn; a false
+ * pass costs a duplicate, and the maintenance cycle finds duplicates later.
+ *
+ * Deliberately no model call: correctness that requires one per write belongs in the
+ * background, not in the turn.
+ */
+/** `- **Premium:** €33/month`, `Premium: €33/month`, `| Premium | €33 |`. */
+const KEY_VALUE = /^\s*(?:[-*+]\s*)?(?:\*\*|__)?([A-Za-z][\w\s'/-]{1,40}?)(?:\*\*|__)?\s*:\s*(.+?)\s*$/;
+const TABLE_ROW = /^\s*\|\s*(?:\*\*)?([A-Za-z][\w\s'/-]{1,40}?)(?:\*\*)?\s*\|\s*(.+?)\s*\|/;
+/**
+ * A value worth fighting over. A conflict between two prose sentences is usually
+ * two ways of saying the same thing; a conflict between two numbers is a fact
+ * that changed.
+ */
+const HARD_VALUE = /\d|\b(yes|no|true|false|none|active|inactive|expired|cancelled|monthly|weekly|annual|annually)\b/i;
+/**
+ * Pulls `attribute: value` shapes out of text about to be written. Structural
+ * only — this is what makes the check affordable on every write.
+ */
+function extractCandidates(text, startLine = 1) {
+    const out = [];
+    const lines = text.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+        const raw = lines[i];
+        if (raw.trim().length === 0 || /^\s*#{1,6}\s/.test(raw))
+            continue;
+        const match = TABLE_ROW.exec(raw) ?? KEY_VALUE.exec(raw);
+        if (!match)
+            continue;
+        const attribute = normalizeAttribute(match[1]);
+        const value = match[2].trim();
+        if (attribute.length === 0 || value.length === 0)
+            continue;
+        // A URL or a wikilink is not an attribute assignment, whatever the colon says.
+        if (/^\/\/|^https?:|^\[\[/.test(value))
+            continue;
+        if (!HARD_VALUE.test(value))
+            continue;
+        out.push({ attribute, value, line: startLine + i, text: raw.trim() });
+    }
+    return out;
+}
+function normalizeAttribute(raw) {
+    return raw.toLowerCase().replace(/[*_`]/g, '').replace(/\s+/g, ' ').trim();
+}
+/**
+ * Two values differ *meaningfully* when their comparable cores differ. Reached
+ * only for values that already contain a number or a decisive word, so this is
+ * about "€33 vs €33/month" (same) against "€33 vs €47" (different).
+ *
+ * Exported for the thorough pass, which joins facts across the whole knowledge base and
+ * has to decide "differ" exactly the way the inline check does. Two answers to that question
+ * would mean the cycle reporting conflicts a write would have allowed, or missing ones it
+ * would have blocked.
+ */
+export function valuesConflict(existing, incoming) {
+    const left = comparableCore(existing);
+    const right = comparableCore(incoming);
+    if (left === right)
+        return false;
+    const leftNumbers = numbersIn(existing);
+    const rightNumbers = numbersIn(incoming);
+    // Both carry numbers: the numbers decide. This is the case to bias toward, and the only
+    // one where "differ" is unambiguous.
+    if (leftNumbers.length > 0 && rightNumbers.length > 0) {
+        return leftNumbers.join(',') !== rightNumbers.join(',');
+    }
+    // Only one side has a number, or neither does. When uncertain, write.
+    return false;
+}
+function comparableCore(value) {
+    return value.toLowerCase().replace(/[*_`]/g, '').replace(/[\s,]/g, '').replace(/\.$/, '');
+}
+function numbersIn(value) {
+    // Thousands separators removed first, so `1,450` reads as one number.
+    return [...value.replace(/(\d),(\d{3})\b/g, '$1$2').matchAll(/\d+(?:[.]\d+)?/g)].map((m) => m[0]);
+}
+/**
+ * Returns the first genuine conflict, or null. First rather than all: a caller has
+ * to take this to the user, and one clear question beats a list.
+ *
+ * Both sides go through the **same extractor**, which is the whole trick. The first
+ * implementation compared a structurally-extracted attribute from the incoming text
+ * against the `attribute` a model had assigned to an existing fact — and those are
+ * different vocabularies. Appending `- Nights: 5` over an existing `- Nights: 3`
+ * produced no conflict at all, because the model had labelled the existing line's
+ * attribute `total` while the extractor read the new one as `nights`. Two names for
+ * the same thing never join.
+ *
+ * Comparing the page's own lines against the incoming lines also means conflict
+ * detection **works with no chat model at all**, which is what makes it cheap.
+ */
+export function detectConflict(options) {
+    const incoming = extractCandidates(options.incoming, 1);
+    if (incoming.length === 0)
+        return null;
+    const existing = extractCandidates(options.body, options.bodyStartLine);
+    if (existing.length === 0)
+        return null;
+    // A low-confidence fact is never used for conflict detection, where a shaky
+    // claim would fight a solid one. Lines the deriver was unsure about are excluded
+    // by line number — the one thing the facts table is genuinely authoritative on.
+    const shaky = new Set(options.store.db
+        .prepare(`SELECT f.line_start FROM facts f JOIN pages p ON p.id = f.page_id
+            WHERE f.page_id = ? AND f.valid_to IS NULL AND f.confidence < 0.5
+              AND p.derived_hash = p.body_hash`)
+        .all(options.pageId).map((row) => row.line_start));
+    for (const candidate of incoming) {
+        for (const current of existing) {
+            if (shaky.has(current.line))
+                continue;
+            if (current.attribute !== candidate.attribute)
+                continue;
+            if (!valuesConflict(current.value, candidate.value))
+                continue;
+            const token = conflictToken(options.slug, current.line, candidate.value);
+            if (options.resolveToken === token)
+                continue; // The caller already asked.
+            return {
+                slug: options.slug,
+                line: current.line,
+                existing: current.text,
+                incoming: candidate.text,
+                subject: candidate.attribute,
+                token,
+            };
+        }
+    }
+    return null;
+}
+/**
+ * Ties an override to the exact conflict it resolves. A plain boolean flag would
+ * let a caller wave through a *different* conflict discovered on the next attempt
+ * — which is the same as not checking.
+ */
+function conflictToken(slug, line, incoming) {
+    return createHash('sha256').update(`${slug}:${line}:${incoming}`).digest('hex').slice(0, 12);
+}
+//# sourceMappingURL=conflict.js.map

package/dist/write/conflict.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"conflict.js","sourceRoot":"","sources":["../../src/write/conflict.ts"],"names":[],"mappings":"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"}

package/dist/write/edit.d.ts

@@ -0,0 +1,59 @@
+/**
+ * The four ways `write` can change a body, and the rule they obey: **never touch the
+ * frontmatter, unless the caller sent one.** Every key is preserved byte for byte, so an
+ * edit here operates on the body and splices it back under the original head.
+ *
+ * The exception is `content` — a whole-page write — and it is not a loophole. `read` returns
+ * the file including its frontmatter, so a caller that read a page, revised it and sent the
+ * result back arrives holding a block; and `role`, `management` and `temporal` are declarable
+ * nowhere else in the write API, so rewriting the declaration is a thing a caller legitimately
+ * means. The old behaviour spliced that block under the existing head and produced a page with
+ * two, the second invisible to everything that reads frontmatter. Adopting it is both what the
+ * caller asked for and the only reading that cannot silently accumulate.
+ */
+export type BodyEdit = {
+    kind: 'content';
+    content: string;
+} | {
+    kind: 'append';
+    text: string;
+    section?: string;
+} | {
+    kind: 'patch';
+    patch: string;
+} | {
+    kind: 'replace';
+    find: string;
+    with: string;
+};
+export interface EditResult {
+    content: string;
+    /** Lines that changed, for the journal summary and the write report. */
+    firstChangedLine: number | null;
+    /**
+     * Set when the write carried its own frontmatter block and it replaced the page's.
+     * `dropped` names the keys the old block declared and the new one does not, because a
+     * caller rewriting a declaration from memory is the likeliest way to lose a key nobody
+     * meant to remove — and a rewrite nobody can see is the failure this whole path exists
+     * to stop repeating.
+     */
+    frontmatter?: {
+        adopted: true;
+        dropped: string[];
+    };
+}
+export declare function applyEdit(original: string, edit: BodyEdit): EditResult;
+/**
+ * A strict unified-diff applier: every context and removal line must match the
+ * file exactly, or the whole patch is refused.
+ *
+ * Strictness is the feature. A fuzzy applier that "finds the nearest match" will
+ * eventually apply a hunk to the wrong place, and in a knowledge base that means a
+ * value silently attached to the wrong subject — the exact failure Akno exists
+ * to prevent. Refusing costs the caller a re-read; guessing costs correctness.
+ *
+ * The `@@` line numbers are treated as a hint, not as truth: agents get them wrong
+ * constantly, and the context lines identify the location unambiguously anyway.
+ */
+export declare function applyUnifiedDiff(body: string, patch: string): string;
+//# sourceMappingURL=edit.d.ts.map

package/dist/write/edit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"edit.d.ts","sourceRoot":"","sources":["../../src/write/edit.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;GAYG;AAEH,MAAM,MAAM,QAAQ,GAChB;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GACpC;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CAAE,GAClD;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAChC;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC;AAEpD,MAAM,WAAW,UAAU;IACzB,OAAO,EAAE,MAAM,CAAC;IAChB,wEAAwE;IACxE,gBAAgB,EAAE,MAAM,GAAG,IAAI,CAAC;IAChC;;;;;;OAMG;IACH,WAAW,CAAC,EAAE;QAAE,OAAO,EAAE,IAAI,CAAC;QAAC,OAAO,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC;CACpD;AAED,wBAAgB,SAAS,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,QAAQ,GAAG,UAAU,CA8BtE;AA2ID;;;;;;;;;;;GAWG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAkBpE"}