@modelprofile.com/flexharness 10.0.0 → 10.1.0

package/dist_ts_stores_nosqldb/classes.recordstore.js

@@ -0,0 +1,437 @@
+import * as plugins from './plugins.js';
+import { FlexHarnessStoreCommitUncertainError, FlexHarnessStoreFormatError, FlexHarnessValidationError, } from '../dist_ts/errors.js';
+export const FLEX_RECORD_COLLECTION = 'flexharness_records';
+export const FLEX_CHUNK_COLLECTION = 'flexharness_chunks';
+/**
+ * UTF-16 code units a record holds inline, and the size of each chunk of a longer payload. A
+ * chunk stays below 3 MiB of UTF-8, far under the 16 MiB document limit NoSQLDB and MongoDB
+ * enforce, so a record and each of its chunks always fit one document.
+ */
+export const FLEX_RECORD_CHUNK_CODE_UNITS = 1024 * 1024;
+const mutationAttempts = 8;
+const mutationBackoffBaseMs = 5;
+const mutationBackoffMaxMs = 200;
+const chunkReadAttempts = 4;
+const defaultOperationTimeoutMs = 30_000;
+/**
+ * The head of one record. A payload up to one chunk is stored inline; a longer one lives in
+ * immutable chunks named by `blobId`. `writeToken` changes on every committed write and is the
+ * compare-and-swap fence. A head without payload or blob is a placeholder that reserves the
+ * record for a chunked first write; it reads as absent.
+ */
+export class FlexRecordDocument extends plugins.SmartDataDbDoc {
+    recordId;
+    domain;
+    ownerKey;
+    namespaceKey;
+    revision;
+    writeToken;
+    payload;
+    blobId;
+    chunkCount;
+    payloadSha256;
+    /** Set before the first chunk of this record is written; the record's writes then sweep. */
+    chunked;
+    sweepCount;
+}
+/** One immutable piece of a chunked payload, written against the head token it will replace. */
+export class FlexChunkDocument extends plugins.SmartDataDbDoc {
+    chunkId;
+    recordId;
+    domain;
+    ownerKey;
+    namespaceKey;
+    blobId;
+    baseToken;
+    index;
+    data;
+}
+function bindModels(db) {
+    class BoundRecord extends FlexRecordDocument {
+    }
+    class BoundChunk extends FlexChunkDocument {
+    }
+    plugins.defineCollectionModel(BoundRecord, db, {
+        collectionName: FLEX_RECORD_COLLECTION,
+        persistedFields: [
+            'recordId',
+            'domain',
+            'ownerKey',
+            'namespaceKey',
+            'revision',
+            'writeToken',
+            'payload',
+            'blobId',
+            'chunkCount',
+            'payloadSha256',
+            'chunked',
+            'sweepCount',
+        ],
+        numericFields: ['revision', 'chunkCount', 'sweepCount'],
+        identityFields: ['recordId'],
+        indexes: [
+            { name: 'flexharness_record_id', key: { recordId: 1 }, options: { unique: true } },
+            { name: 'flexharness_record_owner', key: { ownerKey: 1, domain: 1 } },
+            { name: 'flexharness_record_namespace', key: { namespaceKey: 1, domain: 1 } },
+        ],
+    });
+    plugins.defineCollectionModel(BoundChunk, db, {
+        collectionName: FLEX_CHUNK_COLLECTION,
+        persistedFields: [
+            'chunkId',
+            'recordId',
+            'domain',
+            'ownerKey',
+            'namespaceKey',
+            'blobId',
+            'baseToken',
+            'index',
+            'data',
+        ],
+        numericFields: ['index'],
+        identityFields: ['chunkId'],
+        indexes: [
+            { name: 'flexharness_chunk_id', key: { chunkId: 1 }, options: { unique: true } },
+            { name: 'flexharness_chunk_blob', key: { blobId: 1 } },
+            { name: 'flexharness_chunk_record', key: { recordId: 1 } },
+            { name: 'flexharness_chunk_owner', key: { ownerKey: 1, domain: 1 } },
+            { name: 'flexharness_chunk_namespace', key: { namespaceKey: 1, domain: 1 } },
+        ],
+    });
+    return { records: BoundRecord, chunks: BoundChunk };
+}
+const digest = (value) => plugins.crypto.createHash('sha256').update(value, 'utf8').digest('hex');
+function splitPayload(text) {
+    const chunks = [];
+    let start = 0;
+    while (start < text.length) {
+        let end = Math.min(start + FLEX_RECORD_CHUNK_CODE_UNITS, text.length);
+        const last = text.charCodeAt(end - 1);
+        if (end < text.length && last >= 0xd800 && last <= 0xdbff)
+            end--;
+        chunks.push(text.slice(start, end));
+        start = end;
+    }
+    return chunks;
+}
+/** A rejection the database states before anything is written; every other failure may have applied. */
+function isDefiniteRejection(error) {
+    return error instanceof plugins.SmartdataPersistenceError && [
+        'invalid_argument',
+        'invalid_configuration',
+        'invalid_document',
+        'unsupported_operation',
+        'unique_conflict',
+    ].includes(error.code);
+}
+/**
+ * Waits before retrying a lost head swap: exponential from 5 ms, capped at 200 ms, with full
+ * jitter over its upper half, so writers that lost the same race spread out.
+ */
+function mutationBackoff(attempt) {
+    const ceiling = Math.min(mutationBackoffMaxMs, mutationBackoffBaseMs * 2 ** (attempt - 1));
+    const delayMs = ceiling / 2 + Math.random() * (ceiling / 2);
+    return new Promise((resolve) => setTimeout(resolve, delayMs));
+}
+function isUniqueConflict(error) {
+    return error instanceof plugins.SmartdataPersistenceError && error.code === 'unique_conflict';
+}
+/**
+ * Compare-and-swap records on `@lossless.org/client/nosqldb`. A write reads the head, decides,
+ * writes any chunks, and swaps the head only while its `writeToken` is unchanged. Chunks of a
+ * replaced or abandoned payload are swept in a transaction that also touches the head, so a
+ * concurrent deletion or writer can never lose chunks its head references.
+ */
+export class FlexRecordStore {
+    db;
+    timeoutMs;
+    records;
+    chunks;
+    preparation;
+    constructor(options) {
+        const timeoutMs = options.operationTimeoutMs ?? defaultOperationTimeoutMs;
+        if (!Number.isSafeInteger(timeoutMs) || timeoutMs < 1 || timeoutMs > 120_000) {
+            throw new FlexHarnessValidationError('operationTimeoutMs must be an integer from 1 to 120000.');
+        }
+        this.db = options.db;
+        this.timeoutMs = timeoutMs;
+        ({ records: this.records, chunks: this.chunks } = bindModels(options.db));
+    }
+    /** Creates or verifies both collections and their indexes once; a failed attempt is retried. */
+    prepare() {
+        this.preparation ??= this.prepareCollections().catch((error) => {
+            this.preparation = undefined;
+            throw error;
+        });
+        return this.preparation;
+    }
+    async prepareCollections() {
+        const capabilities = this.db.capabilities;
+        if (!capabilities) {
+            throw new FlexHarnessValidationError('NoSqlFlexHarnessStores requires an initialized SmartdataDb.');
+        }
+        if (capabilities.transactions === 'unsupported') {
+            throw new FlexHarnessValidationError('NoSqlFlexHarnessStores requires a database that supports transactions.');
+        }
+        const options = { mode: 'ensureCompatible', timeoutMs: this.timeoutMs };
+        await this.records.prepareCollection(options);
+        await this.chunks.prepareCollection(options);
+    }
+    resolve(address) {
+        const recordId = digest(JSON.stringify([
+            address.domain,
+            address.storageKey,
+            address.sessionId ?? null,
+            address.archiveId ?? null,
+        ]));
+        return {
+            recordId,
+            domain: address.domain,
+            ownerKey: digest(JSON.stringify([address.storageKey, address.sessionId ?? null])),
+            namespaceKey: digest(address.storageKey),
+            path: `${FLEX_RECORD_COLLECTION}/${address.domain}/${recordId}`,
+        };
+    }
+    async read(address, validate) {
+        await this.prepare();
+        const resolved = this.resolve(address);
+        return this.parse(resolved, await this.readHead(resolved), validate);
+    }
+    async mutate(address, mutation) {
+        await this.prepare();
+        const resolved = this.resolve(address);
+        let actualRevision = 0;
+        for (let attempt = 0; attempt < mutationAttempts; attempt++) {
+            if (attempt > 0)
+                await mutationBackoff(attempt);
+            const head = await this.readHead(resolved);
+            const current = this.parse(resolved, head, mutation.validate);
+            actualRevision = head.document?.revision ?? 0;
+            const write = mutation.decide(current);
+            if (!write)
+                return;
+            if (await this.commit(resolved, head.document, write))
+                return;
+        }
+        throw mutation.contention(actualRevision);
+    }
+    /** Deletes every record and chunk one session owns in the given domains. */
+    async deleteOwner(storageKey, sessionId, domains) {
+        await this.prepare();
+        const ownerKey = digest(JSON.stringify([storageKey, sessionId]));
+        await this.deleteInTransaction(`${FLEX_RECORD_COLLECTION}/${domains.join('+')}/owner/${ownerKey}`, { ownerKey, domain: { $in: [...domains] } });
+    }
+    /** Deletes every record and chunk of one domain in a storage namespace. */
+    async purgeNamespace(storageKey, domain) {
+        await this.prepare();
+        const namespaceKey = digest(storageKey);
+        await this.deleteInTransaction(`${FLEX_RECORD_COLLECTION}/${domain}/namespace/${namespaceKey}`, { namespaceKey, domain });
+    }
+    async deleteInTransaction(path, selector) {
+        const session = this.db.createSession();
+        try {
+            await session.withTransaction(async (transaction) => {
+                await this.records.atomicDeleteMany(selector, { session: transaction });
+                await this.chunks.atomicDeleteMany(selector, { session: transaction });
+            }, { timeoutMS: this.timeoutMs });
+        }
+        catch (error) {
+            if (plugins.SmartdataSession.getCommitOutcome(error) === 'not_committed')
+                throw error;
+            throw new FlexHarnessStoreCommitUncertainError(path, 'delete', { cause: error });
+        }
+        finally {
+            await session.close();
+        }
+    }
+    parse(resolved, head, validate) {
+        if (head.text === undefined)
+            return undefined;
+        let parsed;
+        try {
+            parsed = JSON.parse(head.text);
+        }
+        catch (error) {
+            throw new FlexHarnessStoreFormatError(`Malformed JSON at ${resolved.path}.`, { cause: error });
+        }
+        try {
+            return validate(parsed);
+        }
+        catch (error) {
+            if (error instanceof FlexHarnessStoreFormatError) {
+                throw new FlexHarnessStoreFormatError(`Invalid record at ${resolved.path}: ${error.message}`, {
+                    cause: error,
+                });
+            }
+            throw error;
+        }
+    }
+    findHead(resolved) {
+        return this.records.getInstance({ recordId: resolved.recordId }, { timeoutMS: this.timeoutMs });
+    }
+    async readHead(resolved) {
+        for (let attempt = 0; attempt < chunkReadAttempts; attempt++) {
+            const document = await this.findHead(resolved);
+            if (!document)
+                return {};
+            if (document.payload !== null)
+                return { document, text: document.payload };
+            if (document.blobId === null)
+                return { document };
+            const text = await this.readBlob(document);
+            if (text !== undefined)
+                return { document, text };
+            const latest = await this.findHead(resolved);
+            if (latest?.writeToken === document.writeToken) {
+                throw new FlexHarnessStoreFormatError(`${resolved.path} references ${document.chunkCount} chunks of blob "${document.blobId}", but they are incomplete.`);
+            }
+        }
+        throw new FlexHarnessStoreFormatError(`${resolved.path} changed during ${chunkReadAttempts} consecutive reads.`);
+    }
+    async readBlob(document) {
+        const stored = await this.chunks.getInstances({ blobId: document.blobId }, { timeoutMS: this.timeoutMs });
+        if (stored.length !== document.chunkCount)
+            return undefined;
+        const text = stored
+            .sort((left, right) => left.index - right.index)
+            .map((chunk) => chunk.data)
+            .join('');
+        return digest(text) === document.payloadSha256 ? text : undefined;
+    }
+    /** Returns false when another writer swapped the head first; nothing of this write remains. */
+    async commit(resolved, stored, write) {
+        const text = JSON.stringify(write.value);
+        const chunked = text.length > FLEX_RECORD_CHUNK_CODE_UNITS;
+        let current = stored;
+        if (!current) {
+            if (!chunked)
+                return this.insertHead(resolved, write.revision, text);
+            current = await this.insertPlaceholder(resolved);
+            if (!current)
+                return false;
+        }
+        else if (current.chunked) {
+            await this.sweep(current);
+        }
+        else if (chunked && !await this.markChunked(current)) {
+            return false;
+        }
+        const blobId = chunked ? await this.writeBlob(resolved, current.writeToken, text) : null;
+        let swapped;
+        try {
+            const outcome = await this.records.atomicUpdate({ recordId: resolved.recordId, writeToken: current.writeToken }, {
+                $set: {
+                    revision: write.revision,
+                    writeToken: plugins.crypto.randomUUID(),
+                    payload: chunked ? null : text,
+                    blobId,
+                    chunkCount: chunked ? splitPayload(text).length : 0,
+                    payloadSha256: chunked ? digest(text) : null,
+                },
+            }, { timeoutMS: this.timeoutMs });
+            swapped = outcome.matchedCount === 1;
+        }
+        catch (error) {
+            if (isDefiniteRejection(error))
+                throw error;
+            throw new FlexHarnessStoreCommitUncertainError(resolved.path, 'write', { cause: error });
+        }
+        if (!swapped && blobId !== null) {
+            await this.chunks.atomicDeleteMany({ blobId }, { timeoutMS: this.timeoutMs });
+        }
+        return swapped;
+    }
+    newHead(resolved) {
+        const head = new this.records();
+        head.recordId = resolved.recordId;
+        head.domain = resolved.domain;
+        head.ownerKey = resolved.ownerKey;
+        head.namespaceKey = resolved.namespaceKey;
+        head.writeToken = plugins.crypto.randomUUID();
+        head.blobId = null;
+        head.chunkCount = 0;
+        head.payloadSha256 = null;
+        head.sweepCount = 0;
+        return head;
+    }
+    async insertHead(resolved, revision, text) {
+        const head = this.newHead(resolved);
+        head.revision = revision;
+        head.payload = text;
+        head.chunked = false;
+        try {
+            await this.records.insert(head, { timeoutMS: this.timeoutMs });
+            return true;
+        }
+        catch (error) {
+            if (isUniqueConflict(error))
+                return false;
+            if (isDefiniteRejection(error))
+                throw error;
+            throw new FlexHarnessStoreCommitUncertainError(resolved.path, 'write', { cause: error });
+        }
+    }
+    /** Reserves the record for a chunked first write, so its chunks have a head token to replace. */
+    async insertPlaceholder(resolved) {
+        const head = this.newHead(resolved);
+        head.revision = 0;
+        head.payload = null;
+        head.chunked = true;
+        try {
+            await this.records.insert(head, { timeoutMS: this.timeoutMs });
+            return head;
+        }
+        catch (error) {
+            if (isUniqueConflict(error))
+                return undefined;
+            throw error;
+        }
+    }
+    async markChunked(current) {
+        const outcome = await this.records.atomicUpdate({ recordId: current.recordId, writeToken: current.writeToken }, { $set: { chunked: true } }, { timeoutMS: this.timeoutMs });
+        return outcome.matchedCount === 1;
+    }
+    async writeBlob(resolved, baseToken, text) {
+        const blobId = plugins.crypto.randomUUID();
+        const pieces = splitPayload(text);
+        for (let index = 0; index < pieces.length; index++) {
+            const chunk = new this.chunks();
+            chunk.chunkId = `${blobId}:${index}`;
+            chunk.recordId = resolved.recordId;
+            chunk.domain = resolved.domain;
+            chunk.ownerKey = resolved.ownerKey;
+            chunk.namespaceKey = resolved.namespaceKey;
+            chunk.blobId = blobId;
+            chunk.baseToken = baseToken;
+            chunk.index = index;
+            chunk.data = pieces[index];
+            await this.chunks.insert(chunk, { timeoutMS: this.timeoutMs });
+        }
+        return blobId;
+    }
+    /**
+     * Deletes the record's chunks that no head can reference any more: every blob but the current
+     * one that was written against another head token. A writer that read the current token keeps
+     * its chunks. Touching the head in the same transaction makes a concurrent deletion conflict,
+     * so chunks written after a deletion are never swept by a transaction that predates it.
+     */
+    async sweep(current) {
+        const session = this.db.createSession();
+        try {
+            await session.withTransaction(async (transaction) => {
+                const touched = await this.records.atomicUpdate({ recordId: current.recordId, writeToken: current.writeToken }, { $inc: { sweepCount: 1 } }, { session: transaction });
+                if (touched.matchedCount !== 1)
+                    return;
+                await this.chunks.atomicDeleteMany({
+                    recordId: current.recordId,
+                    baseToken: { $ne: current.writeToken },
+                    ...(current.blobId === null ? {} : { blobId: { $ne: current.blobId } }),
+                }, { session: transaction });
+            }, { timeoutMS: this.timeoutMs });
+        }
+        finally {
+            await session.close();
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.recordstore.js","sourceRoot":"","sources":["../../ts_stores_nosqldb/classes.recordstore.ts"],"names":[],"mappings":"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"}

package/dist_ts_stores_nosqldb/index.d.ts

@@ -0,0 +1,2 @@
+export { NoSqlFlexHarnessStores, type INoSqlFlexHarnessStoresOptions, } from './classes.nosqldbstores.js';
+export { FLEX_CHUNK_COLLECTION, FLEX_RECORD_CHUNK_CODE_UNITS, FLEX_RECORD_COLLECTION, } from './classes.recordstore.js';

package/dist_ts_stores_nosqldb/index.js

@@ -0,0 +1,3 @@
+export { NoSqlFlexHarnessStores, } from './classes.nosqldbstores.js';
+export { FLEX_CHUNK_COLLECTION, FLEX_RECORD_CHUNK_CODE_UNITS, FLEX_RECORD_COLLECTION, } from './classes.recordstore.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90c19zdG9yZXNfbm9zcWxkYi9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQ0wsc0JBQXNCLEdBRXZCLE1BQU0sNEJBQTRCLENBQUM7QUFDcEMsT0FBTyxFQUNMLHFCQUFxQixFQUNyQiw0QkFBNEIsRUFDNUIsc0JBQXNCLEdBQ3ZCLE1BQU0sMEJBQTBCLENBQUMifQ==

package/dist_ts_stores_nosqldb/plugins.d.ts

@@ -0,0 +1,7 @@
+import * as crypto from 'node:crypto';
+export { crypto };
+import { AgentEventStoreConflictError, ToolJobStoreConflictError } from '@modelprofile.com/flexharness-agent';
+export { AgentEventStoreConflictError, ToolJobStoreConflictError };
+export type { IAgentEventArchiveV2, IAgentEventSnapshotV2, IAgentEventStoreV2, IToolJobSnapshot, IToolJobState, IToolJobStore, TAgentEvent, } from '@modelprofile.com/flexharness-agent';
+import { SmartDataDbDoc, SmartdataDb, SmartdataPersistenceError, SmartdataSession, defineCollectionModel } from '@lossless.org/client/nosqldb';
+export { SmartDataDbDoc, SmartdataDb, SmartdataPersistenceError, SmartdataSession, defineCollectionModel, };

package/dist_ts_stores_nosqldb/plugins.js

@@ -0,0 +1,10 @@
+// node native scope
+import * as crypto from 'node:crypto';
+export { crypto };
+// @modelprofile.com scope
+import { AgentEventStoreConflictError, ToolJobStoreConflictError, } from '@modelprofile.com/flexharness-agent';
+export { AgentEventStoreConflictError, ToolJobStoreConflictError };
+// @lossless.org scope
+import { SmartDataDbDoc, SmartdataDb, SmartdataPersistenceError, SmartdataSession, defineCollectionModel, } from '@lossless.org/client/nosqldb';
+export { SmartDataDbDoc, SmartdataDb, SmartdataPersistenceError, SmartdataSession, defineCollectionModel, };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3RzX3N0b3Jlc19ub3NxbGRiL3BsdWdpbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsb0JBQW9CO0FBQ3BCLE9BQU8sS0FBSyxNQUFNLE1BQU0sYUFBYSxDQUFDO0FBRXRDLE9BQU8sRUFBRSxNQUFNLEVBQUUsQ0FBQztBQUVsQiwwQkFBMEI7QUFDMUIsT0FBTyxFQUNMLDRCQUE0QixFQUM1Qix5QkFBeUIsR0FDMUIsTUFBTSxxQ0FBcUMsQ0FBQztBQUU3QyxPQUFPLEVBQUUsNEJBQTRCLEVBQUUseUJBQXlCLEVBQUUsQ0FBQztBQVduRSxzQkFBc0I7QUFDdEIsT0FBTyxFQUNMLGNBQWMsRUFDZCxXQUFXLEVBQ1gseUJBQXlCLEVBQ3pCLGdCQUFnQixFQUNoQixxQkFBcUIsR0FDdEIsTUFBTSw4QkFBOEIsQ0FBQztBQUV0QyxPQUFPLEVBQ0wsY0FBYyxFQUNkLFdBQVcsRUFDWCx5QkFBeUIsRUFDekIsZ0JBQWdCLEVBQ2hCLHFCQUFxQixHQUN0QixDQUFDIn0=

package/package.json

@@ -2,7 +2,7 @@
   "author": "Task Venture Capital GmbH",
   "license": "MIT",
   "name": "@modelprofile.com/flexharness",
-  "version": "10.0.0",
+  "version": "10.1.0",
   "type": "module",
   "description": "Managed agent sessions with tools, MCP, chat, OCR, documents and browser control through focused subpath imports.",
   "main": "./dist_ts/index.js",
@@ -59,11 +59,19 @@
     "./chat/web": {
       "types": "./dist_ts_chat_web/index.d.ts",
       "import": "./dist_ts_chat_web/index.js"
+    },
+    "./chat/harness": {
+      "types": "./dist_ts_chat_harness/index.d.ts",
+      "import": "./dist_ts_chat_harness/index.js"
+    },
+    "./stores/nosqldb": {
+      "types": "./dist_ts_stores_nosqldb/index.d.ts",
+      "import": "./dist_ts_stores_nosqldb/index.js"
     }
   },
   "dependencies": {
-    "@modelprofile.com/flexharness-agent": "10.0.0",
-    "@modelprofile.com/flexharness-models": "10.0.0",
+    "@modelprofile.com/flexharness-agent": "10.1.0",
+    "@modelprofile.com/flexharness-models": "10.1.0",
     "@push.rocks/smartrequest": "^5.5.1",
     "ai": "^7.0.111",
     "zod": "^4.6.5"
@@ -77,7 +85,9 @@
     "ink-text-input": "^6.0.0",
     "react": "^19.2.5",
     "lit": "^3.2.0",
-    "@types/react": "^19.0.0"
+    "@types/react": "^19.0.0",
+    "@lossless.org/client": "^1.17.0",
+    "@design.estate/dees-catalog": "^17.0.0"
   },
   "peerDependenciesMeta": {
     "@modelcontextprotocol/sdk": {
@@ -106,6 +116,12 @@
     },
     "@types/react": {
       "optional": true
+    },
+    "@lossless.org/client": {
+      "optional": true
+    },
+    "@design.estate/dees-catalog": {
+      "optional": true
     }
   },
   "engines": {
@@ -141,6 +157,10 @@
     "dist_ts_chat_cli",
     "ts_chat_web",
     "dist_ts_chat_web",
+    "ts_chat_harness",
+    "dist_ts_chat_harness",
+    "ts_stores_nosqldb",
+    "dist_ts_stores_nosqldb",
     "readme.md",
     "license.md"
   ]

package/readme.md

@@ -61,10 +61,12 @@ or provider SDKs.
 | `/chat` | Portable streaming `ChatSession`, history and usage | None |
 | `/chat/cli` | Ink/React terminal chat | `ink ink-text-input react`; TypeScript: `@types/react` |
 | `/chat/web` | Lit `flexchat-window`, `flexchat-message`, `flexchat-input` | `lit` |
+| `/chat/harness` | `FlexHarnessTranscript` and intents for the `@design.estate/dees-catalog` harness components, browser-safe | `@design.estate/dees-catalog` (types only) |
 | `/kvm` | Browser control, terminal framing and OCR observation | `puppeteer` |
 | `/documents` | PDF and image documents, `extractTextFromPdf` | `@push.rocks/smartpdf`; for image documents `sharp` |
 | `/mcp` | MCP clients and AI SDK tool conversion | `@modelcontextprotocol/sdk` |
 | `/migration` | Existing versioned harness migrations | None |
+| `/stores/nosqldb` | `NoSqlFlexHarnessStores`: cross-process CAS stores on `@lossless.org/client/nosqldb` | `@lossless.org/client` |
 
 The integrations in the last column use optional peer dependencies. Install them
 only for the entrypoints your project imports, for example:
@@ -1068,6 +1070,8 @@ After every harness using a `JsonFileFlexHarnessStores` instance has been dispos
 
 The JSON stores are explicitly not cross-process safe. When several processes can access the same storage namespace, every core `IFlexHarnessStores` domain and `stores.projectManagement` must use database-backed or equivalent cross-process CAS. Process-local CAS for the core stores or for PM alone is insufficient: session generation creation, cleanup tombstones, PM replacement, and stale-writer rejection must all retain their respective atomic preconditions across processes.
 
+`NoSqlFlexHarnessStores` from `/stores/nosqldb` is that database-backed bundle for every domain. Pass it an initialized `SmartdataDb` and `await stores.prepare()` at startup, before the first harness uses it; the subpath readme describes chunked snapshots and failure reporting.
+
 Direct store operations and non-run session mutations surface conflicts as `FlexHarnessStoreConflictError` or the corresponding AgentSession store conflict. Malformed, wrong-schema, or non-JSON snapshots are surfaced as `FlexHarnessStoreFormatError`. A write or deletion that changed its target but cannot confirm parent-directory durability surfaces `FlexHarnessStoreCommitUncertainError` with the affected path, operation, and cause. Run persistence failures cross the external error boundary and therefore become `FlexHarnessExternalError`. FlexHarness does not merge conflicts.
 
 Each domain serializes its own mutations. A successful run first persists a hidden completed projection, then finalizes the canonical Agent generation as `accepted`, then promotes the hidden projection publicly. Recovery uses the canonical generation outcome to promote an accepted stage or publish a failed/cancelled projection. Failed and cancelled generations remain auditable but never enter future model context.

package/ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@modelprofile.com/flexharness',
-  version: '10.0.0',
+  version: '10.1.0',
   description: 'The FlexHarness toolbox source repository and shared dependency catalog.'
 }