@tangleai/store 0.20.1 → 0.24.1

package/CHANGELOG.md

@@ -1,5 +1,84 @@
 # @tangleai/store
 
+## 0.24.1
+
+### Patch Changes
+
+- Update the Jaren foundation to 0.86.0 with exact registry and source pins. Qualify supervised Node SQLite execution, outcome replay after native backups, and physical-model authoring through the shared Data editor. Document the available relational, migration, cursor and collection-drag mechanisms and their host boundaries.
+- @tangleai/config@0.24.1
+  - @tangleai/core@0.24.1
+  - @tangleai/documents@0.24.1
+  - @tangleai/mas@0.24.1
+  - @tangleai/memory@0.24.1
+  - @tangleai/outcomes@0.24.1
+
+## 0.24.0
+
+### Minor Changes
+
+- Add the outcomes package for independently evidenced decisions, deterministic scoring, atomic confidence projection, bounded artifact refinement and explicitly approved promotion and rollback. The public operation contract, two-domain adapter kit and keyless example share the same scoped request receipts, one-use held-out gates, full head revision checks and interruption recovery.
+
+  The store adapter owns outcome records and memory changes in one SQLite transaction. The new pure confidence helper preserves fact fields; existing applyOutcome calls retain their original duplicate-citation and timestamp behavior and do not acquire a durable replay guarantee. No existing persisted memory format changes. Hosts opt into the new lifecycle, provide evidence and approval authority, and use a new artifact key for schema or policy changes. Scripted paired measurements and Node/Bun packed consumers qualify the mechanism; downstream domain integrations and automatic promotion remain separate work.
+
+### Patch Changes
+
+- Updated dependencies
+  - @tangleai/outcomes@0.24.0
+  - @tangleai/memory@0.24.0
+  - @tangleai/config@0.24.0
+  - @tangleai/core@0.24.0
+  - @tangleai/documents@0.24.0
+  - @tangleai/mas@0.24.0
+
+## 0.23.0
+
+### Patch Changes
+
+- Updated dependencies
+  - @tangleai/memory@0.23.0
+  - @tangleai/config@0.23.0
+  - @tangleai/core@0.23.0
+  - @tangleai/documents@0.23.0
+  - @tangleai/mas@0.23.0
+
+## 0.22.0
+
+### Patch Changes
+
+- @tangleai/config@0.22.0
+  - @tangleai/core@0.22.0
+  - @tangleai/documents@0.22.0
+  - @tangleai/mas@0.22.0
+  - @tangleai/memory@0.22.0
+
+## 0.21.1
+
+### Patch Changes
+
+- Update the exact Jaren foundation dependencies and source pin to the published
+  0.84.3 release after verifying its AI-free archives against source-built bytes.
+  Retain Tangle's model, context and agent ownership and align the development
+  Node pin with 24.20.0. Tangle publication remains a manual author action.
+  Allow release preparation after an already committed local release while
+  preserving its record and rejecting unprepared version edits.
+- Updated dependencies
+  - @tangleai/core@0.21.1
+  - @tangleai/config@0.21.1
+  - @tangleai/mas@0.21.1
+  - @tangleai/documents@0.21.1
+  - @tangleai/memory@0.21.1
+
+## 0.21.0
+
+### Patch Changes
+
+- Updated dependencies
+  - @tangleai/core@0.21.0
+  - @tangleai/config@0.21.0
+  - @tangleai/mas@0.21.0
+  - @tangleai/documents@0.21.0
+  - @tangleai/memory@0.21.0
+
 ## 0.20.1
 
 ### Patch Changes

package/README.md

@@ -5,3 +5,71 @@ Tangle AI persistence — the MemoryStore contract over SQLite via @jarenjs/db,
 Install with `npm install @tangleai/store`. The npm distribution provides ESM JavaScript, TypeScript declarations, and the documented package subpaths for Node 24 and Bun 1.4 or newer.
 
 See the [Tangle documentation](https://github.com/jklarenbeek/tangleai#readme) for architecture, examples, and runtime requirements. All public Tangle packages use one coordinated version.
+
+## Execution hosts and backups
+
+`openTangleDb` accepts the published Jaren `OpenStoreOptions`, with an optional
+driver. Its default selects the synchronous Node or Bun SQLite driver. Injected
+drivers use the same Store, transactions, memory, outcome and MAS adapters.
+
+Jaren 0.86.0 adds `nodeProcessDriver` from `@jarenjs/db/node-process`. Retain the
+opened owner and pass it through a driver adapter to `openTangleDb`; supervise
+ordinary store/service calls with `owner.supervise`. The
+[runnable Node example](../../examples/supervised-store.ts) exercises both outcome
+domains, waits for owner exit, reopens and proves zero-effect replay:
+
+```sh
+npm run store:supervised:smoke
+node examples/supervised-store.ts --db /tmp/supervised-outcomes.sqlite
+```
+
+Share one process driver per host ownership domain. A response deadline fences
+the owner; `settled()` separately reports OS exit and replacement eligibility.
+Reopen and inspect durable receipts before retrying an uncertain write. No
+automatic replay or restart is added. This host has no synchronous/live-query
+surface; importing it on Bun works, while opening refuses with `JD0003`.
+
+`db.backupTo(path)` retains the ordinary Jaren maintenance contract, including
+atomic destination replacement. Node uses online backup; Bun uses disk-backed
+VACUUM INTO without materializing the database in JavaScript. A Bun copy remains
+synchronous native work, without incremental native cancellation. Tests restore
+WAL-backed outcome receipts on both runtimes and verify zero-effect replay.
+
+Native physical schemas and migrations remain direct Jaren operations; this
+package does not convert existing collections or grant raw SQL callers outcome
+service authority. See the [integration audit](../../docs/JARENJS_INTEGRATION.md)
+for ownership, compatibility and available mechanisms.
+
+## Atomic outcome storage
+
+`createOutcomeStore(db)` implements `@tangleai/outcomes`' atomic owner over Jaren
+immediate transactions, with `outcome_records`, `outcome_keys`, `outcome_heads`
+and `outcome_operations` alongside the existing `memories` collection. Immutable
+records carry per-scope sequence values. Head activation compares version and
+revision; projection changes current memory confidence and its terminal receipt
+in the same transaction. Its `memories` property is that same owner's memory
+view, not a separately attached store.
+
+```ts
+import { openTangleDb, createOutcomeStore } from '@tangleai/store';
+const db = await openTangleDb({ path: '/tmp/outcomes.sqlite' });
+const store = createOutcomeStore(db);
+// Pass store to createOutcomeService with the host's scope, adapters and resolver.
+// Close db when the host is finished.
+```
+
+Node and Bun use the installed Jaren SQLite drivers. Tests cover independent
+handles, rollback faults, abrupt process exit, reopening, and zero-effect
+completed replay. A driver busy refusal can require an explicit retry after
+contention. Unknown external completion remains uncertain until host
+reconciliation; SQLite does not make remote effects transactional. A reservation
+is audited before external work, and no-dispatch reconciliation fences the old
+worker. Do not combine this receipt store with unrelated nontransactional memory
+and claim atomic projection.
+
+History filtering and pagination execute as indexed scope/sequence SQL queries
+with LIMIT. That bounds returned records; it is not a driver-wide CPU or scan
+budget. The service caps ancestry traversal and detects corrupt immutable bytes.
+Raw database writes remain trusted-host administration, outside supported API
+authority guarantees. See [the outcome kit](../outcomes/docs/ADAPTERS.md) and the
+[measured replay](../../docs/OUTCOME_BENCHMARK.md).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tangleai/store",
-  "version": "0.20.1",
+  "version": "0.24.1",
   "description": "Tangle AI persistence — the MemoryStore contract over SQLite via @jarenjs/db, plus the run/event log the DAG surface reads",
   "license": "MIT",
   "type": "module",
@@ -46,6 +46,11 @@
       "types": "./src/ledger-storage.d.ts",
       "import": "./src/ledger-storage.js",
       "default": "./src/ledger-storage.js"
+    },
+    "./outcome-store": {
+      "types": "./src/outcome-store.d.ts",
+      "import": "./src/outcome-store.js",
+      "default": "./src/outcome-store.js"
     }
   },
   "engines": {
@@ -53,14 +58,15 @@
   },
   "sideEffects": false,
   "dependencies": {
-    "@tangleai/documents": "^0.20.1",
-    "@tangleai/core": "^0.20.1",
-    "@tangleai/config": "^0.20.1",
-    "@jarenjs/db": "0.83.3",
-    "@jarenjs/validate": "0.83.3",
-    "@tangleai/mas": "^0.20.1",
-    "@jarenjs/core": "0.83.3",
-    "@tangleai/memory": "^0.20.1"
+    "@tangleai/documents": "^0.24.1",
+    "@tangleai/core": "^0.24.1",
+    "@tangleai/config": "^0.24.1",
+    "@jarenjs/db": "0.86.0",
+    "@jarenjs/validate": "0.86.0",
+    "@tangleai/mas": "^0.24.1",
+    "@jarenjs/core": "0.86.0",
+    "@tangleai/memory": "^0.24.1",
+    "@tangleai/outcomes": "^0.24.1"
   },
   "private": false,
   "types": "./src/index.d.ts",

package/src/index.d.ts

@@ -3,6 +3,8 @@ export { TANGLE_DB_MODEL } from './model.ts';
 export { openTangleDb, pickDriver } from './db.ts';
 export type { TangleDb, DbCollection, OpenTangleDbOptions } from './db.ts';
 export { createDbMemoryStore, asRows } from './memory-store.ts';
+export { createOutcomeStore } from './outcome-store.ts';
+export type { OutcomeStoreOptions } from './outcome-store.ts';
 export type { DbMemoryStoreOptions } from './memory-store.ts';
 export { createRunLog } from './runs.ts';
 export type { RunLog, RunRecord, RunEvent, RunLogOptions, RunIdentityStatus, RunView } from './runs.ts';

package/src/index.js

@@ -2,6 +2,7 @@
 export { TANGLE_DB_MODEL } from "./model.js";
 export { openTangleDb, pickDriver } from "./db.js";
 export { createDbMemoryStore, asRows } from "./memory-store.js";
+export { createOutcomeStore } from "./outcome-store.js";
 export { createRunLog } from "./runs.js";
 export { createIdentityRepository } from "./identities.js";
 export { createDocumentStore } from "./document-store.js";

package/src/model.d.ts

@@ -29,6 +29,89 @@ import type { JsonSchema } from '@tangleai/core/schemas/memory';
 export declare const TANGLE_DB_MODEL: {
     readonly $model: "0.1";
     readonly collections: {
+        readonly outcome_records: {
+            readonly schema: {
+                readonly type: "object";
+                readonly required: readonly ["id", "scopeId"];
+                readonly properties: {
+                    readonly id: JsonSchema;
+                    readonly scopeId: JsonSchema;
+                    readonly artifactKey: JsonSchema;
+                    readonly kind: JsonSchema;
+                    readonly seq: {
+                        readonly type: "integer";
+                    };
+                };
+            };
+            readonly key: "/id";
+            readonly indexes: readonly [{
+                readonly name: "by_scope_sequence";
+                readonly path: readonly ["$.scopeId", "$.seq"];
+            }, {
+                readonly name: "by_artifact_kind";
+                readonly path: readonly ["$.scopeId", "$.artifactKey", "$.kind"];
+            }];
+        };
+        readonly outcome_keys: {
+            readonly schema: {
+                readonly type: "object";
+                readonly required: readonly ["id", "scopeId"];
+                readonly properties: {
+                    readonly id: JsonSchema;
+                    readonly scopeId: JsonSchema;
+                    readonly artifactKey: JsonSchema;
+                    readonly kind: JsonSchema;
+                    readonly seq: {
+                        readonly type: "integer";
+                    };
+                };
+            };
+            readonly key: "/id";
+            readonly indexes: readonly [{
+                readonly name: "by_scope";
+                readonly path: "$.scopeId";
+            }];
+        };
+        readonly outcome_heads: {
+            readonly schema: {
+                readonly type: "object";
+                readonly required: readonly ["id", "scopeId"];
+                readonly properties: {
+                    readonly id: JsonSchema;
+                    readonly scopeId: JsonSchema;
+                    readonly artifactKey: JsonSchema;
+                    readonly kind: JsonSchema;
+                    readonly seq: {
+                        readonly type: "integer";
+                    };
+                };
+            };
+            readonly key: "/id";
+            readonly indexes: readonly [{
+                readonly name: "by_scope";
+                readonly path: "$.scopeId";
+            }];
+        };
+        readonly outcome_operations: {
+            readonly schema: {
+                readonly type: "object";
+                readonly required: readonly ["id", "scopeId"];
+                readonly properties: {
+                    readonly id: JsonSchema;
+                    readonly scopeId: JsonSchema;
+                    readonly artifactKey: JsonSchema;
+                    readonly kind: JsonSchema;
+                    readonly seq: {
+                        readonly type: "integer";
+                    };
+                };
+            };
+            readonly key: "/id";
+            readonly indexes: readonly [{
+                readonly name: "by_artifact";
+                readonly path: readonly ["$.scopeId", "$.artifactKey"];
+            }];
+        };
         readonly memories: {
             readonly schema: {
                 readonly type: "object";

package/src/model.js

@@ -29,6 +29,26 @@ const ID = { type: 'string', minLength: 1 };
 export const TANGLE_DB_MODEL = {
     $model: '0.1',
     collections: {
+        outcome_records: {
+            schema: { type: 'object', required: ['id', 'scopeId'], properties: { id: ID, scopeId: ID, artifactKey: ID, kind: ID, seq: { type: 'integer' } } },
+            key: '/id',
+            indexes: [{ name: 'by_scope_sequence', path: ['$.scopeId', '$.seq'] }, { name: 'by_artifact_kind', path: ['$.scopeId', '$.artifactKey', '$.kind'] }],
+        },
+        outcome_keys: {
+            schema: { type: 'object', required: ['id', 'scopeId'], properties: { id: ID, scopeId: ID, artifactKey: ID, kind: ID, seq: { type: 'integer' } } },
+            key: '/id',
+            indexes: [{ name: 'by_scope', path: '$.scopeId' }],
+        },
+        outcome_heads: {
+            schema: { type: 'object', required: ['id', 'scopeId'], properties: { id: ID, scopeId: ID, artifactKey: ID, kind: ID, seq: { type: 'integer' } } },
+            key: '/id',
+            indexes: [{ name: 'by_scope', path: '$.scopeId' }],
+        },
+        outcome_operations: {
+            schema: { type: 'object', required: ['id', 'scopeId'], properties: { id: ID, scopeId: ID, artifactKey: ID, kind: ID, seq: { type: 'integer' } } },
+            key: '/id',
+            indexes: [{ name: 'by_artifact', path: ['$.scopeId', '$.artifactKey'] }],
+        },
         memories: {
             schema: { type: 'object', required: ['id'], properties: { id: ID } },
             key: '/id',

package/src/outcome-store.d.ts

@@ -0,0 +1,7 @@
+/** Outcomes use the database's transaction owner, including memory projection. */
+import { type OutcomeStore } from '@tangleai/outcomes';
+import type { TangleDb } from './db.ts';
+export interface OutcomeStoreOptions {
+    applyProbe?: (step: string) => void;
+}
+export declare function createOutcomeStore(db: TangleDb, options?: OutcomeStoreOptions): OutcomeStore;

package/src/outcome-store.js

@@ -0,0 +1,32 @@
+/** Outcomes use the database's transaction owner, including memory projection. */
+import { createOutcomeStoreAdapter } from '@tangleai/outcomes';
+import { asRows } from "./memory-store.js";
+const names = { records: 'outcome_records', keys: 'outcome_keys', heads: 'outcome_heads', operations: 'outcome_operations', memories: 'memories' };
+export function createOutcomeStore(db, options = {}) {
+    const persistence = { transaction: (task) => db.transaction(async (tx) => {
+            const view = {
+                async get(table, id) { return tx.collection(names[table]).get(id); },
+                async put(table, value) { await tx.collection(names[table]).put(value); options.applyProbe?.(`put:${table}`); },
+                async delete(table, id) { await tx.collection(names[table]).delete(id); options.applyProbe?.(`delete:${table}`); },
+                async query(table, q) {
+                    const where = [];
+                    for (const field of ['scopeId', 'artifactKey', 'kind'])
+                        if (q[field] !== undefined)
+                            where.push({ $eq: [`$r.${field}`, { $const: q[field] }] });
+                    if (q.reservedOnly)
+                        where.push({ $eq: ['$r.capacityReserved', true] });
+                    if (q.after !== undefined)
+                        where.push({ $gt: ['$r.seq', q.after] });
+                    if (q.upper !== undefined)
+                        where.push({ $le: ['$r.seq', q.upper] });
+                    const query = { $for: { r: '$[*]' }, ...(where.length ? { $where: { $and: where } } : {}), $orderby: table === 'records' ? ['$r.seq', '$r.id'] : ['$r.id'], $return: '$r' };
+                    const bounded = q.limit === undefined ? query : { $subsequence: [query, 0, q.limit] };
+                    return asRows(await tx.collection(names[table]).execute(bounded));
+                },
+            };
+            const result = await task(view);
+            options.applyProbe?.('commit');
+            return result;
+        }, { mode: 'immediate' }) };
+    return createOutcomeStoreAdapter(persistence);
+}