@tangleai/store 0.24.1 → 0.25.0

package/CHANGELOG.md

@@ -1,5 +1,30 @@
 # @tangleai/store
 
+## 0.25.0
+
+### Patch Changes
+
+- Enforce semantic template binding targets, monotone caps and tool subsets at admission and instantiation. Pin and capture host message adapter versions, check child graph bindings, and preserve optional no-change instantiation.
+
+  Enforce workflow concurrency through Jaren scheduling, retain failed physical request costs in durable receipts, restore switch outputs from committed branches, and preserve hierarchical message paths. Advance the runtime checkpoint ABI for the changed execution semantics.
+
+  Compose durable human waits through nested graphs, switches and loop iterations.
+  Derive interaction ids from full paths, reconcile the current reserved resume
+  segment, and reject conflicting response bytes under an existing key. Drain
+  started host lifetimes before reporting failure or suspension.
+
+  Enforce physical-request context and retained trace quotas, retain the shared
+  account's provider-total or estimated token charge, and claim-fence cumulative
+  active-time settlement across resumable segments. Quota refusals roll back the
+  attempted payload while retaining actual failure costs.
+- Updated dependencies
+  - @tangleai/mas@0.25.0
+  - @tangleai/config@0.25.0
+  - @tangleai/core@0.25.0
+  - @tangleai/documents@0.25.0
+  - @tangleai/memory@0.25.0
+  - @tangleai/outcomes@0.25.0
+
 ## 0.24.1
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tangleai/store",
-  "version": "0.24.1",
+  "version": "0.25.0",
   "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",
@@ -58,15 +58,15 @@
   },
   "sideEffects": false,
   "dependencies": {
-    "@tangleai/documents": "^0.24.1",
-    "@tangleai/core": "^0.24.1",
-    "@tangleai/config": "^0.24.1",
+    "@tangleai/documents": "^0.25.0",
+    "@tangleai/core": "^0.25.0",
+    "@tangleai/config": "^0.25.0",
     "@jarenjs/db": "0.86.0",
     "@jarenjs/validate": "0.86.0",
-    "@tangleai/mas": "^0.24.1",
+    "@tangleai/mas": "^0.25.0",
     "@jarenjs/core": "0.86.0",
-    "@tangleai/memory": "^0.24.1",
-    "@tangleai/outcomes": "^0.24.1"
+    "@tangleai/memory": "^0.25.0",
+    "@tangleai/outcomes": "^0.25.0"
   },
   "private": false,
   "types": "./src/index.d.ts",

package/src/mas-jobs.js

@@ -102,7 +102,7 @@ export async function ensurePendingMasSegments(db, masStore) {
     for (const run of runs) {
         counts.examined += 1;
         const trace = await masStore.readTrace(run.id);
-        const responded = trace?.interactions.find((interaction) => interaction.status === 'responded' && interaction.resumeSegment !== null);
+        const responded = trace?.interactions.find((interaction) => interaction.status === 'responded' && interaction.resumeSegment === run.segment + 1);
         if (responded === undefined || responded.resumeSegment === null) {
             counts.skipped += 1;
             continue;

package/src/mas-store.d.ts

@@ -8,7 +8,7 @@
  * worker claim epoch (`TMAS2005` for a zombie's stale commit), and node
  * completion as ONE transaction writing the terminal attempt, outbound
  * messages, next state revision, budget snapshot and artifact rows —
- * all or nothing, exactly D6. Every record validates against the
+ * all or nothing. Every record validates against the
  * generated runtime contracts before it is written; persistence never
  * invents a shape. Semantic idempotency: `beginNodeAttempt` returns the
  * stored completion for a key it has already committed and refuses an

package/src/mas-store.js

@@ -8,7 +8,7 @@
  * worker claim epoch (`TMAS2005` for a zombie's stale commit), and node
  * completion as ONE transaction writing the terminal attempt, outbound
  * messages, next state revision, budget snapshot and artifact rows —
- * all or nothing, exactly D6. Every record validates against the
+ * all or nothing. Every record validates against the
  * generated runtime contracts before it is written; persistence never
  * invents a shape. Semantic idempotency: `beginNodeAttempt` returns the
  * stored completion for a key it has already committed and refuses an
@@ -47,6 +47,27 @@ export function createMasStore(db, options = {}) {
             throw error;
         }
     }
+    async function readTraceFrom(reader, runId) {
+        const run = await reader.collection('mas_runs').get(runId);
+        if (run === undefined)
+            return undefined;
+        const view = {
+            run: structuredClone(run),
+            attempts: asRows(await reader.collection('mas_node_attempts').execute(matching({ runId }))).map((row) => structuredClone(row)),
+            messages: asRows(await reader.collection('mas_messages').execute(matching({ runId }))).map((row) => structuredClone(row)),
+            stateRevisions: asRows(await reader.collection('mas_state_revisions').execute(matching({ runId }))).map((row) => structuredClone(row)),
+            interactions: asRows(await reader.collection('mas_interactions').execute(matching({ runId }))).map((row) => structuredClone(row)),
+            artifacts: asRows(await reader.collection('mas_trace_artifacts').execute(matching({ runId }))).map((row) => structuredClone(row)),
+        };
+        return view;
+    }
+    async function enforceTraceLimit(txn, runId) {
+        const trace = await readTraceFrom(txn, runId);
+        const limit = trace?.run.budget.limits?.traceBytes;
+        if (limit !== undefined && new TextEncoder().encode(JSON.stringify(trace)).byteLength > limit) {
+            throw new MasRollback(refuse('TMAS2009', '/limits/traceBytes', 'the retained trace byte budget is spent; the completion was rolled back'));
+        }
+    }
     async function putImmutable(collection, key, value, keyMember) {
         return atomically(async (txn) => {
             const handle = txn.collection(collection);
@@ -221,13 +242,24 @@ export function createMasStore(db, options = {}) {
                 if (!transition.ok)
                     return { ok: false, issue: transition.issue };
                 const next = { ...run, status: transition.status };
+                if (command.settlement) {
+                    const receipt = command.settlement;
+                    if (receipt.claimSeq !== run.claim.seq)
+                        return refuse('TMAS2005', '/claim', 'a stale segment cannot settle the budget');
+                    if (Object.values(receipt.spent).some(n => !Number.isFinite(n) || n < 0))
+                        return refuse('TMAS2009', '/budget/spent', 'invalid budget settlement');
+                    next.budget = { limits: run.budget.limits, spent: { turns: Math.max(run.budget.spent.turns, receipt.spent.turns), tokens: Math.max(run.budget.spent.tokens, receipt.spent.tokens), ms: Math.max(run.budget.spent.ms, receipt.spent.ms) } };
+                }
                 if (command.kind === 'complete')
                     next.output = command.output;
                 if (command.kind === 'fail')
                     next.failure = command.failure;
                 if (command.kind === 'queue-segment')
                     next.segment = run.segment + 1;
-                return writeRun(txn, next);
+                const written = await writeRun(txn, next);
+                if (written.ok && (command.kind === 'complete' || command.kind === 'wait'))
+                    await enforceTraceLimit(txn, runId);
+                return written;
             });
         },
         async putRunFsm(runId, controlId, snapshot) {
@@ -235,7 +267,10 @@ export function createMasStore(db, options = {}) {
                 const run = await readRun(txn, runId);
                 if (run === undefined)
                     return refuse('TMAS2002', '/id', `run '${runId}' does not exist`);
-                return writeRun(txn, { ...run, fsm: { ...run.fsm, [controlId]: snapshot } });
+                const written = await writeRun(txn, { ...run, fsm: { ...run.fsm, [controlId]: snapshot } });
+                if (written.ok)
+                    await enforceTraceLimit(txn, runId);
+                return written;
             });
         },
         async beginNodeAttempt(plan) {
@@ -351,12 +386,13 @@ export function createMasStore(db, options = {}) {
                         spent: {
                             turns: spent.turns + plan.spend.turns,
                             tokens: spent.tokens + plan.spend.tokens,
-                            ms: spent.ms + plan.spend.ms,
+                            ms: Math.max(spent.ms + plan.spend.ms, plan.activeMs ?? 0),
                         },
                     },
                 });
                 if (!written.ok)
                     throw new MasRollback({ ok: false, issue: written.issue });
+                await enforceTraceLimit(txn, plan.runId);
                 return {
                     ok: true,
                     value: {
@@ -382,12 +418,19 @@ export function createMasStore(db, options = {}) {
                 if (current.status !== 'running') {
                     return refuse('TMAS2003', '/status', `only a running attempt can move to '${plan.status}'; '${plan.attemptId}' is '${current.status}'`);
                 }
-                const next = { ...current, status: plan.status, error: plan.error, finishedAt: now() };
+                const next = { ...current, ...plan.receipt, status: plan.status, error: plan.error, finishedAt: now() };
                 const outcome = validateRuntimeRecord('masNodeAttempt', next);
                 if (!outcome.valid) {
                     return refuse('TMAS2004', `/attempt${outcome.issues[0]?.path ?? ''}`, outcome.issues[0]?.detail ?? '');
                 }
                 await handle.put(next);
+                if (plan.receipt !== undefined) {
+                    const charged = plan.receipt.spend, spent = run.budget.spent;
+                    const written = await writeRun(txn, { ...run, budget: { limits: run.budget.limits,
+                            spent: { turns: spent.turns + charged.turns, tokens: spent.tokens + charged.tokens, ms: Math.max(spent.ms + charged.ms, plan.activeMs ?? 0) } } });
+                    if (!written.ok)
+                        throw new MasRollback({ ok: false, issue: written.issue });
+                }
                 return { ok: true, value: structuredClone(next) };
             });
         },
@@ -396,7 +439,7 @@ export function createMasStore(db, options = {}) {
                 const run = await readRun(txn, plan.runId);
                 if (run === undefined)
                     return refuse('TMAS2002', '/id', `run '${plan.runId}' does not exist`);
-                const id = `${plan.runId}:i:${plan.node}`;
+                const id = `${plan.runId}:i:${plan.path}`;
                 const handle = txn.collection('mas_interactions');
                 const existing = await handle.get(id);
                 if (existing !== undefined)
@@ -423,6 +466,7 @@ export function createMasStore(db, options = {}) {
                     return refuse('TMAS2004', `/interaction${outcome.issues[0]?.path ?? ''}`, outcome.issues[0]?.detail ?? '');
                 }
                 await handle.put(interaction);
+                await enforceTraceLimit(txn, plan.runId);
                 return { ok: true, value: structuredClone(interaction) };
             });
         },
@@ -437,6 +481,8 @@ export function createMasStore(db, options = {}) {
                 if (current === undefined)
                     return refuse('TMAS2007', '/id', `interaction '${id}' does not exist`);
                 if (current.status === 'responded' && current.responseKey === responseKey) {
+                    if (!equalsJson(current.response, response))
+                        return refuse('TMAS2007', '/response', 'the response key already identifies different response bytes');
                     return { ok: true, value: structuredClone(current) };
                 }
                 const transition = planInteractionTransition(current.status, 'responded');
@@ -506,19 +552,6 @@ export function createMasStore(db, options = {}) {
             const latest = rows.at(-1);
             return latest === undefined ? undefined : { id: latest.id, value: structuredClone(latest.value) };
         },
-        async readTrace(runId) {
-            const run = await runs().get(runId);
-            if (run === undefined)
-                return undefined;
-            const view = {
-                run: structuredClone(run),
-                attempts: asRows(await attempts().execute(matching({ runId }))).map((row) => structuredClone(row)),
-                messages: asRows(await db.collection('mas_messages').execute(matching({ runId }))).map((row) => structuredClone(row)),
-                stateRevisions: asRows(await db.collection('mas_state_revisions').execute(matching({ runId }))).map((row) => structuredClone(row)),
-                interactions: asRows(await db.collection('mas_interactions').execute(matching({ runId }))).map((row) => structuredClone(row)),
-                artifacts: asRows(await db.collection('mas_trace_artifacts').execute(matching({ runId }))).map((row) => structuredClone(row)),
-            };
-            return view;
-        },
+        async readTrace(runId) { return readTraceFrom(db, runId); },
     };
 }