memtrails 0.2.0 → 0.4.0

package/dist/core/model.js

@@ -4,12 +4,10 @@
  * pinned size and SHA-256. 218 MB. The model is Google's, under the Gemma Terms of Use (ai.google.dev/gemma/terms);
  * memtrails does not ship it.
  */
-import { createHash } from 'node:crypto';
-import { createWriteStream, existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from 'node:fs';
+import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
-import { Readable } from 'node:stream';
-import { pipeline } from 'node:stream/promises';
 import { cacheDir } from './paths.js';
+import { downloadVerified, withLock } from './qdrant-binary.js';
 export const MODEL_REPO = 'onnx-community/embeddinggemma-300m-ONNX';
 export const MODEL_REVISION = '5090578d9565bb06545b4552f76e6bc2c93e4a66';
 export const MODEL_FILES = [
@@ -23,52 +21,43 @@ export function defaultModelDir() {
 }
 const marker = (dir) => join(dir, '.verified');
 const stamp = MODEL_FILES.map((f) => `${f.rel}:${f.size}:${f.sha256}`).join('\n');
+/** Every file in place at its pinned size, and the marker written after the last of them was verified. */
 export function modelReady(dir = defaultModelDir()) {
     try {
-        return readFileSync(marker(dir), 'utf8') === stamp && MODEL_FILES.every((f) => existsSync(join(dir, f.rel)));
+        return readFileSync(marker(dir), 'utf8') === stamp &&
+            MODEL_FILES.every((f) => existsSync(join(dir, f.rel)) && statSync(join(dir, f.rel)).size === f.size);
     }
     catch {
         return false;
     }
 }
-/** The model in `dir` (fetched and checked unless it is already there); the directory, ready for `modelDir`. */
+/**
+ * The model in `dir` (fetched and checked unless it is already there); the directory, ready for `modelDir`. Each file
+ * is fetched to a temp of its own, checked on disk and renamed into place; one run at a time per `dir` (withLock), and
+ * the marker is taken away first, so a set left half-replaced is never taken as ready.
+ */
 export async function ensureModel(opts = {}) {
     const dir = opts.dir ?? defaultModelDir();
     if (modelReady(dir))
         return dir;
-    opts.log?.(`[memtrails] fetching ${MODEL_REPO} (218 MB, Gemma Terms of Use)`);
-    for (const f of MODEL_FILES) {
-        const path = join(dir, f.rel);
-        mkdirSync(dirname(path), { recursive: true });
-        const part = `${path}.part`;
-        rmSync(part, { force: true });
-        const res = await (opts.fetchImpl ?? fetch)(`https://huggingface.co/${MODEL_REPO}/resolve/${MODEL_REVISION}/${f.rel}`, { signal: opts.signal, redirect: 'follow' });
-        if (!res.ok || !res.body)
-            throw new Error(`HTTP ${res.status} for ${f.rel}`);
-        const hash = createHash('sha256');
-        let size = 0;
-        try {
-            await pipeline(Readable.fromWeb(res.body), async function* (src) {
-                for await (const chunk of src) {
-                    const b = chunk;
-                    hash.update(b);
-                    size += b.length;
-                    yield b;
-                }
-            }, createWriteStream(part));
-        }
-        catch (err) {
-            rmSync(part, { force: true });
-            throw err;
+    mkdirSync(dir, { recursive: true });
+    return withLock(dir, async () => {
+        if (modelReady(dir))
+            return dir; // another run finished it while this one waited
+        opts.log?.(`[memtrails] fetching ${MODEL_REPO} (218 MB, Gemma Terms of Use)`);
+        rmSync(marker(dir), { force: true });
+        for (const f of MODEL_FILES) {
+            const path = join(dir, f.rel);
+            const { file, tmp } = await downloadVerified(`https://huggingface.co/${MODEL_REPO}/resolve/${MODEL_REVISION}/${f.rel}`, dirname(path), f, opts);
+            try {
+                renameSync(file, path);
+            }
+            finally {
+                rmSync(tmp, { recursive: true, force: true });
+            }
         }
-        const digest = hash.digest('hex');
-        if (size !== f.size || digest !== f.sha256) {
-            rmSync(part, { force: true });
-            throw new Error(`${f.rel}: got ${size} bytes sha256 ${digest}, expected ${f.size} ${f.sha256}`);
-        }
-        renameSync(part, path);
-    }
-    writeFileSync(marker(dir), stamp);
-    opts.log?.('[memtrails] embedding model ready');
-    return dir;
+        writeFileSync(marker(dir), stamp);
+        opts.log?.('[memtrails] embedding model ready');
+        return dir;
+    }, { signal: opts.signal });
 }

package/dist/core/profiles.d.ts

@@ -1,4 +1,4 @@
-import type { ConsolidateDeps } from './consolidate.js';
+import { type ConsolidateDeps } from './consolidate.js';
 import type { MemoryItem, MemoryScope } from './store.js';
 export declare const PROFILE_MIN_ITEMS = 3;
 export declare const PROFILE_BROAD = 0.2;

package/dist/core/profiles.js

@@ -1,8 +1,8 @@
 /**
  * Profiles — what memory knows about one subject, gathered in one place (sleep's last step).
  *
- * A question about a subject whose facts were told over many conversations ("when did John join the brigade, and what
- * did he do there?") needs the dated facts of all of them, and a top 10 holds a few. For every concept enough long-term
+ * A question about a subject whose facts were told over many conversations ("when did Dana join the choir, and what
+ * did she sing there?") needs the dated facts of all of them, and a top 10 holds a few. For every concept enough long-term
  * items share — at least PROFILE_MIN_ITEMS of a project's items, and on at most PROFILE_BROAD of them (not the person
  * themselves, not the project's own name) — the fast model gathers what they say into one dated list of facts, word for
  * word: a `profile` item, keyed and searched like any other, whose provenance is every source it read.
@@ -18,6 +18,7 @@
 import { createHash } from 'node:crypto';
 import { redactString } from './redact.js';
 import { defaultAsk } from '../llm.js';
+import { stamped } from './consolidate.js';
 import { conceptKey, cut } from './text.js';
 import { writeLtm } from './writer.js';
 export const PROFILE_MIN_ITEMS = 3;
@@ -86,15 +87,15 @@ export function profileSubjects(items, sizes) {
     return out;
 }
 const promptOf = (s) => `SUBJECT: ${s.concept}\n\nMEMORIES:\n${s.read.map((it) => `- (${when(it)}) ${it.title}: ${cut(it.summary.replace(/\s+/g, ' '), PROFILE_LINE)}`).join('\n')}`;
-function profileItem(s, title, facts) {
+function profileItem(s, title, facts, now) {
     const newest = s.read[s.read.length - 1];
-    return {
+    return stamped({
         uid: s.uid, kind: 'profile', scope: s.scope, project: s.project, engine: newest.engine, session: null, cwd: newest.cwd,
         where: s.concept, ts: Math.max(...s.read.map((it) => it.ts)), firstTs: Math.min(...s.read.map((it) => it.firstTs || it.ts)),
         title: cut(title.trim() || s.concept, 120), summary: facts.join('\n'), body: '', files: [], appliesWhen: '',
         confidence: 'curated', importance: 3, status: 'active', provenance: [...new Set(s.read.flatMap((it) => it.provenance))],
         seen: 1, fingerprint: s.fingerprint, concepts: [s.concept],
-    };
+    }, now);
 }
 /** Profiles written for the subjects whose items changed (at most `max`, several asks at once), and archived for the
  *  subjects that no longer qualify. An ask the model did not answer stops the night's profiles; the next night asks
@@ -137,7 +138,7 @@ export async function writeProfiles(d, max = PROFILES_PER_SLEEP) {
             const facts = (Array.isArray(answer.facts) ? answer.facts : []).filter((f) => typeof f === 'string' && !!f.trim()).map((f) => f.trim());
             if (!facts.length)
                 continue;
-            const it = profileItem(s, typeof answer.title === 'string' ? answer.title : '', facts);
+            const it = profileItem(s, typeof answer.title === 'string' ? answer.title : '', facts, (d.now ?? Date.now)());
             await writeLtm(d, [it]);
             d.ltm.put([it]);
             r.profiled++;

package/dist/core/qdrant-binary.d.ts

@@ -12,14 +12,48 @@ export declare function qdrantAsset(platform?: string, arch?: string): QdrantAss
 export declare function qdrantDir(): string;
 export declare function qdrantBinaryPath(a?: QdrantAsset | null): string | null;
 export declare const QDRANT_RELEASE_BASE = "https://github.com/qdrant/qdrant/releases/download/v1.20.0";
-/** The binary is in place and its archive was verified when it was unpacked. */
+/** The binary is in place, its archive was verified when it was unpacked, and no one else could have changed it since. */
 export declare function qdrantReady(a?: QdrantAsset | null): boolean;
+/** A download given up after this long without a byte (the answer's headers included). */
+export declare const DOWNLOAD_STALL_MS = 60000;
+export interface DownloadOptions {
+    signal?: AbortSignal;
+    fetchImpl?: typeof fetch;
+    stallMs?: number;
+}
+/**
+ * `url` fetched into a fresh temp folder inside `dir`, never to a fixed name: two first runs at once (two processes, or
+ * two memories opened together in one) wrote the same `.part` and could rename each other's half-written file. The
+ * file is then checked as it is on disk, not as it streamed past, against its pinned size and SHA-256. Returns the
+ * file and its folder; the caller renames the file into place and removes the folder. Throws (leaving nothing) on a
+ * failure, a mismatch, or `stallMs` without a byte.
+ */
+export declare function downloadVerified(url: string, dir: string, pin: {
+    size: number;
+    sha256: string;
+}, o?: DownloadOptions): Promise<{
+    file: string;
+    tmp: string;
+}>;
+/** A lock not touched for this long is a dead holder's (the holder touches it every quarter of this). */
+export declare const LOCK_STALE_MS = 120000;
 /**
- * Fetch, verify and unpack the binary unless it is already there. Throws on a network failure, a size or hash
- * mismatch (the download is deleted), or a platform Qdrant does not ship for; the caller retries with backoff.
+ * `f` run holding `<path>.lock`, created with O_EXCL: a second first run, in another process or this one, waits and
+ * then finds the first one's result. A lock whose process is gone, or untouched for `staleMs`, is taken over. Nothing
+ * rests on the lock for correctness (every file is verified in a private temp and renamed into place); it keeps two
+ * runs from fetching the same hundreds of MB, and from swapping folders under each other.
  */
-export declare function ensureQdrant(opts?: {
+export declare function withLock<T>(path: string, f: () => Promise<T>, o?: {
     signal?: AbortSignal;
+    staleMs?: number;
+    pollMs?: number;
+}): Promise<T>;
+/**
+ * Fetch, verify and unpack the binary unless it is already there. Throws on a network failure or stall, a size or
+ * hash mismatch (the download is deleted), a platform Qdrant does not ship for, or a folder others could change; the
+ * caller retries with backoff. `asset` is for tests: another archive with its own pins.
+ */
+export declare function ensureQdrant(opts?: DownloadOptions & {
     log?: (line: string) => void;
-    fetchImpl?: typeof fetch;
+    asset?: QdrantAsset;
 }): Promise<string>;

package/dist/core/qdrant-binary.js

@@ -1,15 +1,16 @@
 /**
  * The Qdrant binary memory runs when you give it no Qdrant server of your own: one pinned release, fetched on first use
  * from Qdrant's GitHub release, verified against the size and SHA-256 pinned below, unpacked next to it (cache dir,
- * paths.ts), and trusted after that through a `.verified` marker.
+ * paths.ts), and trusted after that through a `.verified` marker while the folder is this user's alone.
  *
  * Qdrant publishes no checksums, so the hashes are pinned here from its release. Upgrading means a new version and new
  * hashes; Qdrant reads storage only from the minor version before it, so after a version change the index is written
  * again from the logs (rebuild.ts) rather than migrated: it is derived data.
  */
-import { createHash } from 'node:crypto';
-import { chmodSync, createWriteStream, existsSync, mkdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from 'node:fs';
-import { join } from 'node:path';
+import { createHash, randomBytes } from 'node:crypto';
+import { chmodSync, closeSync, createReadStream, createWriteStream, existsSync, lstatSync, mkdirSync, mkdtempSync, openSync, readFileSync, renameSync, rmSync, statSync, utimesSync, writeFileSync, writeSync, } from 'node:fs';
+import { hostname } from 'node:os';
+import { dirname, join } from 'node:path';
 import { Readable } from 'node:stream';
 import { pipeline } from 'node:stream/promises';
 import { spawn } from 'node:child_process';
@@ -34,75 +35,211 @@ export function qdrantBinaryPath(a = qdrantAsset()) {
 }
 export const QDRANT_RELEASE_BASE = `https://github.com/qdrant/qdrant/releases/download/v${QDRANT_VERSION}`;
 const assetUrl = (a) => `${QDRANT_RELEASE_BASE}/${a.asset}`;
-/** The binary is in place and its archive was verified when it was unpacked. */
+/**
+ * Run only what this user alone could have put there: the folder, the binary and its marker owned by this user, no
+ * symlink, writable by no one else. The archive's hash is pinned but not the unpacked binary's (that needs every
+ * platform's archive to compute), so on a shared machine this is what stops a binary swapped in after unpacking.
+ * Windows has no owner bits; there the user's profile ACLs keep others out.
+ */
+function ownedSafely(path) {
+    if (typeof process.getuid !== 'function')
+        return true;
+    const st = lstatSync(path);
+    return !st.isSymbolicLink() && st.uid === process.getuid() && (st.mode & 0o022) === 0;
+}
+/** The binary is in place, its archive was verified when it was unpacked, and no one else could have changed it since. */
 export function qdrantReady(a = qdrantAsset()) {
     const bin = qdrantBinaryPath(a);
-    if (!a || !bin || !existsSync(bin))
+    if (!a || !bin)
         return false;
+    const marker = join(qdrantDir(), '.verified');
     try {
-        return readFileSync(join(qdrantDir(), '.verified'), 'utf8').trim() === `${a.size}:${a.sha256}`;
+        return readFileSync(marker, 'utf8').trim() === `${a.size}:${a.sha256}` && statSync(bin).size > 0 &&
+            [qdrantDir(), bin, marker].every(ownedSafely);
     }
     catch {
         return false;
     }
 }
+/** The system's tar; on Windows by full path, so a `tar.exe` in the working folder or on a planted PATH is not run. */
+function tarProgram() {
+    return process.platform === 'win32' ? join(process.env.SystemRoot || 'C:\\Windows', 'System32', 'tar.exe') : 'tar';
+}
 /** Unpack one archive with the system's tar (bsdtar on macOS and Windows reads zip too). */
 function untar(archive, into) {
     return new Promise((resolve, reject) => {
-        const child = spawn('tar', ['-xf', archive, '-C', into], { stdio: 'ignore' });
+        const child = spawn(tarProgram(), ['-xf', archive, '-C', into], { stdio: 'ignore' });
         child.once('error', reject);
         child.once('exit', (code) => (code === 0 ? resolve() : reject(new Error(`tar exited ${code}`))));
     });
 }
+/** A download given up after this long without a byte (the answer's headers included). */
+export const DOWNLOAD_STALL_MS = 60_000;
 /**
- * Fetch, verify and unpack the binary unless it is already there. Throws on a network failure, a size or hash
- * mismatch (the download is deleted), or a platform Qdrant does not ship for; the caller retries with backoff.
+ * `url` fetched into a fresh temp folder inside `dir`, never to a fixed name: two first runs at once (two processes, or
+ * two memories opened together in one) wrote the same `.part` and could rename each other's half-written file. The
+ * file is then checked as it is on disk, not as it streamed past, against its pinned size and SHA-256. Returns the
+ * file and its folder; the caller renames the file into place and removes the folder. Throws (leaving nothing) on a
+ * failure, a mismatch, or `stallMs` without a byte.
  */
-export async function ensureQdrant(opts = {}) {
-    const a = qdrantAsset();
-    if (!a)
-        throw new Error(`no Qdrant build for ${process.platform}-${process.arch}`);
-    const bin = qdrantBinaryPath(a);
-    if (qdrantReady(a))
-        return bin;
-    const dir = qdrantDir();
+export async function downloadVerified(url, dir, pin, o = {}) {
     mkdirSync(dir, { recursive: true });
-    const archive = join(dir, a.asset);
-    const part = `${archive}.part`;
-    rmSync(part, { force: true });
-    opts.log?.(`[memtrails] fetching Qdrant ${QDRANT_VERSION} (${Math.round(a.size / 1e6)} MB)`);
-    const res = await (opts.fetchImpl ?? fetch)(assetUrl(a), { signal: opts.signal, redirect: 'follow' });
-    if (!res.ok || !res.body)
-        throw new Error(`HTTP ${res.status} for ${a.asset}`);
-    const hash = createHash('sha256');
-    let size = 0;
+    const tmp = mkdtempSync(join(dir, '.download-'));
+    const file = join(tmp, 'file');
+    const name = url.slice(url.lastIndexOf('/') + 1);
+    const stallMs = o.stallMs ?? DOWNLOAD_STALL_MS;
+    const stalled = new AbortController();
+    let timer;
+    const arm = () => {
+        clearTimeout(timer);
+        timer = setTimeout(() => stalled.abort(new Error(`${name}: no data for ${Math.round(stallMs / 1000)} s`)), stallMs);
+    };
+    const signal = o.signal ? AbortSignal.any([o.signal, stalled.signal]) : stalled.signal;
     try {
+        arm();
+        const res = await (o.fetchImpl ?? fetch)(url, { signal, redirect: 'follow' });
+        if (!res.ok || !res.body)
+            throw new Error(`HTTP ${res.status} for ${name}`);
+        let size = 0;
         await pipeline(Readable.fromWeb(res.body), async function* (src) {
             for await (const chunk of src) {
-                const b = chunk;
-                hash.update(b);
-                size += b.length;
-                yield b;
+                arm();
+                size += chunk.length;
+                if (size > pin.size)
+                    throw new Error(`${name}: more than the expected ${pin.size} bytes`);
+                yield chunk;
             }
-        }, createWriteStream(part));
+        }, createWriteStream(file, { flags: 'wx', mode: 0o600 }), { signal });
+        clearTimeout(timer);
+        const hash = createHash('sha256');
+        for await (const chunk of createReadStream(file))
+            hash.update(chunk);
+        const got = { size: statSync(file).size, sha256: hash.digest('hex') };
+        if (got.size !== pin.size || got.sha256 !== pin.sha256) {
+            throw new Error(`${name}: got ${got.size} bytes sha256 ${got.sha256}, expected ${pin.size} ${pin.sha256}`);
+        }
+        return { file, tmp };
     }
     catch (err) {
-        rmSync(part, { force: true });
-        throw err;
+        rmSync(tmp, { recursive: true, force: true });
+        throw stalled.signal.aborted ? stalled.signal.reason : err;
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+/** A lock not touched for this long is a dead holder's (the holder touches it every quarter of this). */
+export const LOCK_STALE_MS = 120_000;
+function lockStale(lock, staleMs) {
+    try {
+        const [pid, host] = readFileSync(lock, 'utf8').split(' ');
+        if (host === hostname() && Number(pid) !== process.pid) {
+            try {
+                process.kill(Number(pid), 0);
+            }
+            catch (err) {
+                if (err.code === 'ESRCH')
+                    return true; // its process is gone
+            }
+        }
+        return Date.now() - statSync(lock).mtimeMs > staleMs;
+    }
+    catch {
+        return false; // gone meanwhile: just try again
     }
-    const digest = hash.digest('hex');
-    if (size !== a.size || digest !== a.sha256) {
-        rmSync(part, { force: true });
-        throw new Error(`${a.asset}: got ${size} bytes sha256 ${digest}, expected ${a.size} ${a.sha256}`);
+}
+/**
+ * `f` run holding `<path>.lock`, created with O_EXCL: a second first run, in another process or this one, waits and
+ * then finds the first one's result. A lock whose process is gone, or untouched for `staleMs`, is taken over. Nothing
+ * rests on the lock for correctness (every file is verified in a private temp and renamed into place); it keeps two
+ * runs from fetching the same hundreds of MB, and from swapping folders under each other.
+ */
+export async function withLock(path, f, o = {}) {
+    const lock = `${path}.lock`;
+    const staleMs = o.staleMs ?? LOCK_STALE_MS;
+    const mine = `${process.pid} ${hostname()} ${randomBytes(8).toString('hex')}`;
+    mkdirSync(dirname(lock), { recursive: true });
+    for (;;) {
+        try {
+            const fd = openSync(lock, 'wx', 0o600);
+            writeSync(fd, mine);
+            closeSync(fd);
+            break;
+        }
+        catch (err) {
+            if (err.code !== 'EEXIST')
+                throw err;
+        }
+        if (lockStale(lock, staleMs)) {
+            rmSync(lock, { force: true });
+            continue;
+        }
+        o.signal?.throwIfAborted();
+        await new Promise((ok) => setTimeout(ok, o.pollMs ?? 250));
     }
-    renameSync(part, archive);
-    await untar(archive, dir);
-    rmSync(archive, { force: true });
-    if (!existsSync(bin) || statSync(bin).size === 0)
-        throw new Error(`${a.asset} did not contain ${a.exe}`);
-    if (process.platform !== 'win32')
-        chmodSync(bin, 0o755);
-    writeFileSync(join(dir, '.verified'), `${a.size}:${a.sha256}\n`);
-    opts.log?.(`[memtrails] Qdrant ${QDRANT_VERSION} ready`);
-    return bin;
+    const beat = setInterval(() => {
+        try {
+            utimesSync(lock, new Date(), new Date());
+        }
+        catch { /* taken over: nothing to keep alive */ }
+    }, Math.max(10, staleMs / 4));
+    beat.unref();
+    try {
+        return await f();
+    }
+    finally {
+        clearInterval(beat);
+        try {
+            if (readFileSync(lock, 'utf8') === mine)
+                rmSync(lock, { force: true }); // not one taken over meanwhile
+        }
+        catch { /* already gone */ }
+    }
+}
+/**
+ * Fetch, verify and unpack the binary unless it is already there. Throws on a network failure or stall, a size or
+ * hash mismatch (the download is deleted), a platform Qdrant does not ship for, or a folder others could change; the
+ * caller retries with backoff. `asset` is for tests: another archive with its own pins.
+ */
+export async function ensureQdrant(opts = {}) {
+    const a = opts.asset ?? qdrantAsset();
+    if (!a)
+        throw new Error(`no Qdrant build for ${process.platform}-${process.arch}`);
+    const bin = qdrantBinaryPath(a);
+    if (qdrantReady(a))
+        return bin;
+    const dir = qdrantDir();
+    const cache = dirname(dir);
+    mkdirSync(cache, { recursive: true, mode: 0o700 });
+    return withLock(dir, async () => {
+        if (qdrantReady(a))
+            return bin; // another run finished it while this one waited
+        opts.log?.(`[memtrails] fetching Qdrant ${QDRANT_VERSION} (${Math.round(a.size / 1e6)} MB)`);
+        const { file, tmp } = await downloadVerified(assetUrl(a), cache, a, opts);
+        try {
+            // Unpacked into a fresh folder and moved into place whole: never a half-unpacked binary under the real name.
+            const archive = join(tmp, a.asset);
+            renameSync(file, archive);
+            const unpacked = join(tmp, 'unpacked');
+            mkdirSync(unpacked);
+            await untar(archive, unpacked);
+            const exe = join(unpacked, a.exe);
+            if (!existsSync(exe) || !lstatSync(exe).isFile() || statSync(exe).size === 0)
+                throw new Error(`${a.asset} did not contain ${a.exe}`);
+            chmodSync(exe, 0o755);
+            writeFileSync(join(unpacked, '.verified'), `${a.size}:${a.sha256}\n`, { mode: 0o644 });
+            chmodSync(join(unpacked, '.verified'), 0o644);
+            chmodSync(unpacked, 0o755);
+            if (existsSync(dir))
+                renameSync(dir, join(tmp, 'old')); // unverified or not this user's alone; removed with tmp
+            renameSync(unpacked, dir);
+        }
+        finally {
+            rmSync(tmp, { recursive: true, force: true });
+        }
+        if (!qdrantReady(a))
+            throw new Error(`${dir} is not this user's alone (its owner or permissions): not running a binary others could change`);
+        opts.log?.(`[memtrails] Qdrant ${QDRANT_VERSION} ready`);
+        return bin;
+    }, { signal: opts.signal });
 }

package/dist/core/qdrant-client.d.ts

@@ -1,15 +1,14 @@
 import type { QdrantEndpoint } from './qdrant-process.js';
 export declare const COLLECTION = "memory";
-/** The payload field a tenant client keys every point by, and the original point id it keeps beside the scoped one. */
-export declare const TENANT_FIELD = "user";
 export declare const DIMS: 768;
 /** What the index is made of; a change empties it and it is written in again from the logs (rebuild.ts).
  *  2: binary quantisation with rescoring (½ the RAM of int8, recall 0.98–1.00 measured at 1–3M points), keyword terms
  *  folded and segmented for every language (text.ts); 3: on-disk binary copy, HNSW and payload indexes;
  *  4: remote EmbeddingGemma GPU vectors (768 dimensions, explicit runtime/pooling tag in embedder.ts); 5: nothing cut —
  *  every chunk of a body (no 12-chunk limit), short-term entries chunked too, cues numbered below the key, full payloads;
- *  6: every captured request indexed for good — however old, consolidated or not (the raw record is the truth). */
-export declare const INDEX_LAYOUT = 6;
+ *  6: every captured request indexed for good — however old, consolidated or not (the raw record is the truth);
+ *  7: a record's kind (`engine`) on every point of it and indexed, so a kinds filter finds a record by its chunks. */
+export declare const INDEX_LAYOUT = 7;
 export interface SparseVector {
     indices: number[];
     values: number[];
@@ -33,25 +32,14 @@ export declare class QdrantError extends Error {
 export interface QdrantClientOptions {
     /** The collection (COLLECTION when not given). */
     collection?: string;
-    /** Many users in one collection: the user every call is for — read on each call from the caller's context; null or ''
-     *  refuses the call. */
-    tenant?: () => string | null | undefined;
 }
 export declare class QdrantClient {
     private readonly endpoint;
     private readonly timeoutMs;
-    private readonly opts;
-    private readonly collection;
+    /** `/collections/<name>`, the name encoded: a name you give is a path segment, never more of the path. */
+    private readonly at;
     /** `endpoint` may start Qdrant (the service runs it only while memory has work): every call waits for it. */
     constructor(endpoint: () => QdrantEndpoint | null | Promise<QdrantEndpoint | null>, timeoutMs?: number, opts?: QdrantClientOptions);
-    /** The user this call is for (a tenant client), or null (one person's own index). Throws when a tenant client has none. */
-    private user;
-    /** A filter with the user added — unchanged for one person's own index. */
-    private scoped;
-    /** A point's id in a shared collection: the user's and the item's (pointId of both), so users never share a point. */
-    private scopedId;
-    /** What a read hands back: the point's own id (as the writer named it) and only this user's points. */
-    private own;
     private call;
     /** Drop the whole collection: the index is derived, written again from the logs (rebuild.ts). */
     dropCollection(): Promise<void>;
@@ -78,7 +66,7 @@ export declare class QdrantClient {
      *  per-family similarities. An item with no such point is not in the map. */
     bestPerItem(vector: number[], items: string[], part: string, timeoutMs?: number): Promise<Map<string, number>>;
     /** `nearest` for several vectors in one call. */
-    /** `fields`: only these payload fields (and the item and its user), for a caller that needs no more — a walk over
+    /** `fields`: only these payload fields (and the item), for a caller that needs no more — a walk over
      *  many neighbours reads ids, not the bodies of long requests. */
     nearestMany(vectors: number[][], filter: Filter, limit?: number, timeoutMs?: number, fields?: string[]): Promise<Array<Array<{
         item: string;