maka-agent 0.2.0-dev.64.20260929 → 0.2.0-dev.67.20261002

package/node_modules/@maka/storage/dist/session-store.js

@@ -311,7 +311,7 @@ class SqliteSessionStore {
         return (await this.metadata.list(filter, 'ordinary'))
             .filter((record) => record.header.transcriptLedgerVersion !== 0)
             .filter((record) => record.header.conversationCopy?.state !== 'preparing')
-            .map((record) => toCatalogSummary(record.header, record.lastMessagePreview));
+            .map(toCatalogRecordSummary);
     }
     async listCatalogPage(filter, cursor, limit, expectedRevision) {
         await this.ensureCatalogProjectionReadable();
@@ -330,7 +330,7 @@ class SqliteSessionStore {
             records: page.records.map((record) => ({
                 ...projectHeaderSnapshot(record),
                 activityAt: record.activityAt,
-                summary: toCatalogSummary(record.header, record.lastMessagePreview),
+                summary: toCatalogRecordSummary(record),
             })),
             hasMore: page.hasMore,
         };
@@ -360,7 +360,7 @@ class SqliteSessionStore {
         return {
             ...projectHeaderSnapshot(record),
             activityAt: record.activityAt,
-            summary: toCatalogSummary(record.header, record.lastMessagePreview),
+            summary: toCatalogRecordSummary(record),
         };
     }
     async readMessagesSnapshot(sessionId) {
@@ -597,9 +597,12 @@ function projectStableSessionCreateProbe(probe) {
         ? { kind: 'existing', record: projectHeaderSnapshot(probe.record) }
         : probe;
 }
-function toCatalogSummary(header, lastMessagePreview) {
+function toCatalogRecordSummary(record) {
     return {
-        ...toSummary(header),
-        ...(lastMessagePreview === undefined ? {} : { lastMessagePreview }),
+        ...toSummary(record.header),
+        ...(record.lastMessagePreview === undefined
+            ? {}
+            : { lastMessagePreview: record.lastMessagePreview }),
+        ...(record.archivedAt === undefined ? {} : { archivedAt: record.archivedAt }),
     };
 }

package/node_modules/@maka/storage/dist/sqlite-file-set.js

@@ -0,0 +1,22 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+/** The files SQLite may keep beside a database, in any journal mode. */
+export function sqliteDatabaseSidecars(path) {
+    return [`${path}-wal`, `${path}-shm`, `${path}-journal`];
+}

package/node_modules/@maka/storage/dist/sqlite-long-term-memory-store.js

@@ -20,6 +20,7 @@ import { createHash, randomUUID } from 'node:crypto';
 import { closeSync, constants as fsConstants, fchmodSync, fstatSync, lstatSync, openSync, } from 'node:fs';
 import { createRequire } from 'node:module';
 import { MemoryItemStoreConflictError, isMemoryItemKind, isMemoryItemOrigin, isMemoryKeyOrigin, isMemoryKeyType, isMemoryLifecycleState, isMemoryScopeType, isMemoryStatementType, isMemoryTemporalType, normalizeLongTermMemoryContent, validateMemoryTemporalBounds, } from '@maka/core/long-term-memory';
+import { sqliteDatabaseSidecars as databaseSidecars } from './sqlite-file-set.js';
 import { assertSupportedSqliteLongTermMemorySchemaVersion, configureSqliteLongTermMemoryDatabase, migrateSqliteLongTermMemoryDatabase, readSqliteLongTermMemorySchemaVersion, } from './sqlite-long-term-memory-schema.js';
 const MAX_MUTATIONS_PER_OPERATION = 32;
 const MAX_KEYS_PER_ITEM = 32;
@@ -1591,9 +1592,6 @@ function secureFile(path, create, allowUnlinked) {
             closeSync(descriptor);
     }
 }
-function databaseSidecars(path) {
-    return [`${path}-wal`, `${path}-shm`, `${path}-journal`];
-}
 function isNodeError(error) {
     return typeof error === 'object' && error !== null && 'code' in error;
 }

package/node_modules/@maka/storage/dist/sqlite-runtime-store.js

@@ -29,7 +29,7 @@ import { stableJsonStringify } from '@maka/core/tool-args-identity';
 import { mergeRuntimePartialSnapshots, groupRuntimePartialSnapshots, compareRuntimePartialSnapshots, partialRuntimeStream, completedPartialRuntimeStreamKey, } from './runtime-partial-values.js';
 import { assertPreparedInput, assertOutcomeInput, assertPreparedIdentity, assertOutcomeIdentity, } from './tool-commit-validation.js';
 import { encodeCanonicalRuntimeEvent } from '@maka/core/canonical-runtime-event';
-import { scanToolLedger, referencedToolOperationIds, ToolLedgerReducer, ToolLedgerCorruptionError, ToolLedgerRejectionError, validateGenericToolLedgerAppend, validateIncrementalToolLedgerTransition, } from '@maka/core/tool-ledger-scanner';
+import { scanToolLedger, referencedToolOperationIds, ToolLedgerCorruptionError, ToolLedgerRejectionError, validateGenericToolLedgerAppend, validateToolLedgerTransition, } from '@maka/core/tool-ledger-scanner';
 import { buildImmutableRuntimePrefix, buildImmutableRuntimePrefixProof, continuationStartEventMatchesClaim, decodeContinuationClaim, } from '@maka/core/runtime-boundary';
 import { assertToolRecoveryEventBundle, interpretScannedToolRecovery, } from '@maka/core/tool-recovery-bundle';
 import { configureSqliteRuntimeDatabase, migrateSqliteRuntimeDatabase, readUserVersion, RUNTIME_RECOVERY_AUTHORITY_CAPABILITY, RUNTIME_RECOVERY_AUTHORITY_CAPABILITY_VERSION, RUNTIME_CONTINUATION_AUTHORITY_CAPABILITY, RUNTIME_CONTINUATION_AUTHORITY_CAPABILITY_VERSION, RUNTIME_WORKSPACE_VERSION_AUTHORITY_CAPABILITY, RUNTIME_WORKSPACE_VERSION_AUTHORITY_CAPABILITY_VERSION, runtimeEventKind, SQLITE_RUNTIME_SCHEMA_VERSION, } from './sqlite-runtime-schema.js';
@@ -43,12 +43,6 @@ export { SQLITE_RUNTIME_SCHEMA_VERSION } from './sqlite-runtime-schema.js';
 const RUNTIME_EVENT_SCAN_BATCH_SIZE = 128;
 const RUNTIME_PARTIAL_SEGMENT_TARGET_BYTES = 64 * 1024;
 const RECOVERY_MESSAGE_QUERY_BATCH_SIZE = 400;
-const TOOL_LEDGER_CACHE_EVENT_OVERHEAD_BYTES = 1024;
-const DEFAULT_TOOL_LEDGER_CACHE_BUDGET = {
-    maxEntries: 32,
-    maxEstimatedBytes: 16 * 1024 * 1024,
-    maxSingleEntryEstimatedBytes: 8 * 1024 * 1024,
-};
 const IMMUTABLE_STEERING_SQL_PREDICATE = `
   event_kind = 'text'
   AND CASE
@@ -80,19 +74,6 @@ function requireRuntimeEventScanCount(value) {
     }
     return value;
 }
-function normalizeToolLedgerCacheBudget(override) {
-    const budget = { ...DEFAULT_TOOL_LEDGER_CACHE_BUDGET, ...override };
-    for (const [name, value] of Object.entries(budget)) {
-        if (!Number.isSafeInteger(value) || value < 1) {
-            throw new Error(`Invalid tool ledger cache ${name}`);
-        }
-    }
-    return budget;
-}
-function estimateToolLedgerCacheBytes(storedPayloadBytes, eventCount) {
-    const estimate = storedPayloadBytes * 2 + eventCount * TOOL_LEDGER_CACHE_EVENT_OVERHEAD_BYTES;
-    return Number.isSafeInteger(estimate) ? estimate : Number.MAX_SAFE_INTEGER;
-}
 const require = createRequire(import.meta.url);
 function loadDatabaseSync() {
     return require('node:sqlite').DatabaseSync;
@@ -114,26 +95,11 @@ export class SqliteRuntimeStore {
     workspaceVersionAuthorityCapability = WORKSPACE_VERSION_AUTHORITY_CAPABILITY_V1;
     db;
     databaseLease;
-    toolLedgerCacheBudget;
-    toolLedgerCache = new Map();
-    toolLedgerCacheEstimatedBytes = 0;
-    toolLedgerCacheEventCount = 0;
-    toolLedgerCacheMetrics = {
-        hits: 0,
-        misses: 0,
-        budgetEvictions: 0,
-        terminalEvictions: 0,
-        transientEntries: 0,
-    };
-    uncommittedToolLedgerStates = new Map();
-    toolLedgerCacheVersion;
-    localCommittedWriteRevision = 0;
     closed = false;
     uncommittedEventSessions = new Set();
     eventCommitListeners = new Set();
     constructor(path, options = {}) {
         this.options = options;
-        this.toolLedgerCacheBudget = normalizeToolLedgerCacheBudget(options.toolLedgerCacheBudget);
         if (options.readOnly && options.databaseLease) {
             throw new Error('Operational state database leases cannot be opened read-only');
         }
@@ -196,8 +162,6 @@ export class SqliteRuntimeStore {
         if (this.closed)
             return;
         this.closed = true;
-        this.clearToolLedgerCache();
-        this.uncommittedToolLedgerStates.clear();
         if (this.databaseLease)
             this.databaseLease.close();
         else
@@ -241,7 +205,6 @@ export class SqliteRuntimeStore {
                 existing.at(-1)?.id !== canonicalEvent.id) {
                 throw new Error('Terminal RuntimeEvent must be the immutable ledger tail');
             }
-            this.invalidateToolLedgerCacheForInvocation(canonicalEvent.invocationId);
             return;
         }
         const existingTerminal = existing.find(isTerminalRuntimeEvent);
@@ -3086,14 +3049,7 @@ export class SqliteRuntimeStore {
     }
     transaction(operation) {
         if (this.databaseLease) {
-            const nested = this.db.isTransaction;
-            return this.databaseLease.transaction('write', () => {
-                // A sibling lease may have changed the shared transaction view since
-                // this store last used its reconstructible cache.
-                if (nested)
-                    this.clearToolLedgerCache();
-                return operation();
-            });
+            return this.databaseLease.transaction('write', operation);
         }
         this.db.exec('BEGIN IMMEDIATE');
         let result;
@@ -3108,17 +3064,10 @@ export class SqliteRuntimeStore {
             catch {
                 // Preserve the protocol failure that caused rollback.
             }
-            // Reducers may have loaded rows written earlier in this transaction as
-            // their immutable base. Bump the local view even on rollback so the next
-            // admission discards that phantom base before retrying.
-            this.localCommittedWriteRevision += 1;
             this.settleEventCommits(false);
-            this.settleToolLedgerStates(false);
             throw error;
         }
-        this.localCommittedWriteRevision += 1;
         this.settleEventCommits(true);
-        this.settleToolLedgerStates(true);
         return result;
     }
     noteEventCommit(sessionId) {
@@ -3336,12 +3285,9 @@ export class SqliteRuntimeStore {
         }
     }
     assertToolLedgerTransition(candidateEvents, expectedTransition) {
-        const canonicalEncodings = candidateEvents.map(encodeCanonicalRuntimeEvent);
-        const canonicalEvents = canonicalEncodings.map(({ event }) => event);
-        const entry = this.toolLedgerCacheEntry(canonicalEvents);
-        const appendedEncodings = canonicalEncodings.filter(({ event }) => entry.reducer.event(event.id) === undefined);
-        const validation = validateIncrementalToolLedgerTransition({
-            reducer: entry.reducer,
+        const canonicalEvents = candidateEvents.map((event) => encodeCanonicalRuntimeEvent(event).event);
+        const validation = validateToolLedgerTransition({
+            existingEvents: this.readToolLedgerDependencies(canonicalEvents),
             candidateEvents: canonicalEvents,
             expectedTransition,
         });
@@ -3351,40 +3297,15 @@ export class SqliteRuntimeStore {
             }
             throw new ToolLedgerRejectionError(validation.code, validation.eventId);
         }
-        if (validation.appendedEvents === 0)
-            return;
-        this.noteToolLedgerState(entry, validation.checkpoint, canonicalEvents.map((event) => event.invocationId), {
-            eventCount: validation.appendedEvents,
-            estimatedBytes: estimateToolLedgerCacheBytes(appendedEncodings.reduce((bytes, encoding) => bytes + Buffer.byteLength(encoding.json, 'utf8'), 0), validation.appendedEvents),
-        });
     }
-    toolLedgerCacheEntry(candidateEvents) {
-        const currentVersion = this.currentToolLedgerCacheVersion();
-        if (this.toolLedgerCacheVersion !== currentVersion)
-            this.refreshToolLedgerCacheVersion();
-        const directInvocationIds = new Set(candidateEvents.map((event) => event.invocationId));
-        const directOperationIds = referencedToolOperationIds(candidateEvents);
-        for (const invocationId of this.toolLedgerOperationInvocations(directOperationIds)) {
-            directInvocationIds.add(invocationId);
-        }
-        for (const [key, entry] of this.toolLedgerCache) {
-            if (entry.seedInvocationIds.size === directInvocationIds.size &&
-                [...directInvocationIds].every((invocationId) => entry.seedInvocationIds.has(invocationId))) {
-                this.toolLedgerCacheMetrics.hits += 1;
-                this.touchToolLedgerCacheEntry(key, entry);
-                return entry;
-            }
-        }
-        this.toolLedgerCacheMetrics.misses += 1;
-        const invocationIds = new Set(directInvocationIds);
-        const operationIds = new Set(directOperationIds);
+    readToolLedgerDependencies(candidateEvents) {
+        const invocationIds = new Set(candidateEvents.map((event) => event.invocationId));
+        const operationIds = referencedToolOperationIds(candidateEvents);
         const resolvedOperationIds = new Set();
         const loadedInvocationIds = new Set();
         const scopedEvents = [];
-        let storedPayloadBytes = 0;
         const readInvocation = this.db.prepare(`
-      SELECT event_id, session_id, invocation_id, run_id, turn_id, event_seq, payload_json,
-             length(CAST(payload_json AS BLOB)) AS stored_bytes
+      SELECT event_id, session_id, invocation_id, run_id, turn_id, event_seq, payload_json
       FROM runtime_events
       WHERE invocation_id = ?
       ORDER BY event_seq ASC, event_id ASC
@@ -3407,7 +3328,6 @@ export class SqliteRuntimeStore {
                 loadedInvocationIds.add(invocationId);
                 const rows = readInvocation.all(invocationId);
                 for (const row of rows) {
-                    storedPayloadBytes += requireRuntimeEventScanCount(row.stored_bytes);
                     const event = decodeRuntimeEventStorageRow(row);
                     scopedEvents.push({ event, eventSeq: row.event_seq });
                     if (event.refs?.parentOperationId)
@@ -3415,31 +3335,10 @@ export class SqliteRuntimeStore {
                 }
             }
         }
-        const sortedSeedInvocationIds = [...directInvocationIds].sort();
-        const sortedInvocationIds = [...invocationIds].sort();
-        const key = JSON.stringify([sortedSeedInvocationIds, sortedInvocationIds]);
-        const existing = this.toolLedgerCache.get(key);
-        if (existing) {
-            this.touchToolLedgerCacheEntry(key, existing);
-            return existing;
-        }
         scopedEvents.sort((left, right) => left.event.invocationId.localeCompare(right.event.invocationId) ||
             left.eventSeq - right.eventSeq ||
             left.event.id.localeCompare(right.event.id));
-        const entry = {
-            reducer: new ToolLedgerReducer(scopedEvents.map(({ event }) => event)),
-            seedInvocationIds: new Set(sortedSeedInvocationIds),
-            invocationIds: new Set(sortedInvocationIds),
-            eventCount: scopedEvents.length,
-            estimatedBytes: estimateToolLedgerCacheBytes(storedPayloadBytes, scopedEvents.length),
-        };
-        if (this.toolLedgerEntryExceedsAdmissionBudget(entry)) {
-            this.toolLedgerCacheMetrics.transientEntries += 1;
-            return entry;
-        }
-        this.retainToolLedgerCacheEntry(key, entry);
-        this.trimToolLedgerCache();
-        return entry;
+        return scopedEvents.map(({ event }) => event);
     }
     toolLedgerOperationInvocations(operationIds) {
         const ids = [...new Set(operationIds)].sort();
@@ -3459,149 +3358,6 @@ export class SqliteRuntimeStore {
             .all(...ids);
         return new Set(rows.map((row) => row.invocation_id));
     }
-    noteToolLedgerState(entry, checkpoint, invocationIds, delta) {
-        const reducer = entry.reducer;
-        const existing = this.uncommittedToolLedgerStates.get(reducer);
-        if (existing) {
-            for (const invocationId of invocationIds)
-                existing.changedInvocationIds.add(invocationId);
-            this.adjustToolLedgerCacheEntry(entry, delta);
-            return;
-        }
-        if (this.uncommittedToolLedgerStates.size === 0 && this.databaseLease) {
-            this.databaseLease.onTransactionSettled((committed) => this.settleToolLedgerStates(committed));
-        }
-        this.uncommittedToolLedgerStates.set(reducer, {
-            checkpoint,
-            changedInvocationIds: new Set(invocationIds),
-            entry,
-            estimatedBytesBefore: entry.estimatedBytes,
-            eventCountBefore: entry.eventCount,
-        });
-        this.adjustToolLedgerCacheEntry(entry, delta);
-    }
-    settleToolLedgerStates(committed) {
-        const states = [...this.uncommittedToolLedgerStates.entries()];
-        this.uncommittedToolLedgerStates.clear();
-        if (states.length === 0)
-            return;
-        if (!committed) {
-            for (const [reducer, state] of states.reverse()) {
-                reducer.rollback(state.checkpoint);
-                this.restoreToolLedgerCacheEntry(state);
-            }
-            this.trimToolLedgerCache();
-            return;
-        }
-        const retained = new Set(states.map(([reducer]) => reducer));
-        const changedInvocationIds = new Set(states.flatMap(([, state]) => [...state.changedInvocationIds]));
-        for (const [key, entry] of this.toolLedgerCache) {
-            if (retained.has(entry.reducer))
-                continue;
-            if ([...entry.invocationIds].some((id) => changedInvocationIds.has(id))) {
-                this.deleteToolLedgerCacheEntry(key);
-            }
-        }
-        for (const [reducer, state] of states)
-            reducer.commit(state.checkpoint);
-        this.toolLedgerCacheVersion = this.currentToolLedgerCacheVersion();
-        this.trimToolLedgerCache();
-    }
-    refreshToolLedgerCacheVersion() {
-        if (this.uncommittedToolLedgerStates.size > 0) {
-            throw new Error('Cannot invalidate tool ledger state during an open write transaction');
-        }
-        this.clearToolLedgerCache();
-        this.toolLedgerCacheVersion = this.currentToolLedgerCacheVersion();
-    }
-    retainToolLedgerCacheEntry(key, entry) {
-        entry.cacheKey = key;
-        this.toolLedgerCache.set(key, entry);
-        this.toolLedgerCacheEstimatedBytes += entry.estimatedBytes;
-        this.toolLedgerCacheEventCount += entry.eventCount;
-    }
-    touchToolLedgerCacheEntry(key, entry) {
-        this.toolLedgerCache.delete(key);
-        this.toolLedgerCache.set(key, entry);
-    }
-    adjustToolLedgerCacheEntry(entry, delta) {
-        entry.estimatedBytes += delta.estimatedBytes;
-        entry.eventCount += delta.eventCount;
-        if (entry.cacheKey && this.toolLedgerCache.get(entry.cacheKey) === entry) {
-            this.toolLedgerCacheEstimatedBytes += delta.estimatedBytes;
-            this.toolLedgerCacheEventCount += delta.eventCount;
-        }
-    }
-    restoreToolLedgerCacheEntry(state) {
-        const entry = state.entry;
-        if (entry.cacheKey && this.toolLedgerCache.get(entry.cacheKey) === entry) {
-            this.toolLedgerCacheEstimatedBytes += state.estimatedBytesBefore - entry.estimatedBytes;
-            this.toolLedgerCacheEventCount += state.eventCountBefore - entry.eventCount;
-        }
-        entry.estimatedBytes = state.estimatedBytesBefore;
-        entry.eventCount = state.eventCountBefore;
-    }
-    deleteToolLedgerCacheEntry(key, reason) {
-        const entry = this.toolLedgerCache.get(key);
-        if (!entry)
-            return;
-        this.toolLedgerCache.delete(key);
-        if (entry.cacheKey === key)
-            entry.cacheKey = undefined;
-        this.toolLedgerCacheEstimatedBytes -= entry.estimatedBytes;
-        this.toolLedgerCacheEventCount -= entry.eventCount;
-        if (reason === 'budget')
-            this.toolLedgerCacheMetrics.budgetEvictions += 1;
-        if (reason === 'terminal')
-            this.toolLedgerCacheMetrics.terminalEvictions += 1;
-    }
-    clearToolLedgerCache() {
-        for (const entry of this.toolLedgerCache.values())
-            entry.cacheKey = undefined;
-        this.toolLedgerCache.clear();
-        this.toolLedgerCacheEstimatedBytes = 0;
-        this.toolLedgerCacheEventCount = 0;
-    }
-    invalidateToolLedgerCacheForInvocation(invocationId) {
-        for (const [key, entry] of this.toolLedgerCache) {
-            if (entry.invocationIds.has(invocationId)) {
-                this.deleteToolLedgerCacheEntry(key, 'terminal');
-            }
-        }
-    }
-    toolLedgerEntryExceedsAdmissionBudget(entry) {
-        return entry.estimatedBytes > this.toolLedgerCacheBudget.maxSingleEntryEstimatedBytes;
-    }
-    toolLedgerCacheExceedsBudget() {
-        return (this.toolLedgerCache.size > this.toolLedgerCacheBudget.maxEntries ||
-            this.toolLedgerCacheEstimatedBytes > this.toolLedgerCacheBudget.maxEstimatedBytes);
-    }
-    trimToolLedgerCache() {
-        for (;;) {
-            let victim;
-            for (const [key, entry] of this.toolLedgerCache) {
-                if (this.uncommittedToolLedgerStates.has(entry.reducer))
-                    continue;
-                if (this.toolLedgerEntryExceedsAdmissionBudget(entry)) {
-                    victim = key;
-                    break;
-                }
-            }
-            if (!victim && this.toolLedgerCacheExceedsBudget()) {
-                victim = [...this.toolLedgerCache].find(([, entry]) => !this.uncommittedToolLedgerStates.has(entry.reducer))?.[0];
-            }
-            if (!victim)
-                return;
-            this.deleteToolLedgerCacheEntry(victim, 'budget');
-        }
-    }
-    currentToolLedgerCacheVersion() {
-        return `${this.runtimeDataVersion()}:${this.databaseLease?.writeViewRevision() ?? this.localCommittedWriteRevision}`;
-    }
-    runtimeDataVersion() {
-        const row = this.db.prepare('PRAGMA data_version').get();
-        return row.data_version;
-    }
     assertInvocationIdentity(events) {
         const candidates = new Map();
         const runs = new Map();
@@ -3832,9 +3588,6 @@ export class SqliteRuntimeStore {
             if (!allowExactDuplicate) {
                 throw new Error(`RuntimeEvent ${canonicalEvent.id} already exists outside this tool transaction`);
             }
-            if (isTerminalRuntimeEvent(canonicalEvent)) {
-                this.invalidateToolLedgerCacheForInvocation(canonicalEvent.invocationId);
-            }
             return this.runtimeEventSeq(canonicalEvent.id);
         }
         this.assertContinuationAuthorityAllowsEvent(canonicalEvent, authorizedPendingContinuationClaimId);
@@ -3868,9 +3621,6 @@ export class SqliteRuntimeStore {
         recordTranscriptTurnExtent(this.db, { ...canonicalEvent, kind: runtimeEventKind(canonicalEvent) }, ordinal);
         this.noteEventCommit(canonicalEvent.sessionId);
         this.deleteCompletedPartialSnapshot(canonicalEvent);
-        if (isTerminalRuntimeEvent(canonicalEvent)) {
-            this.invalidateToolLedgerCacheForInvocation(canonicalEvent.invocationId);
-        }
         return next;
     }
     deleteCompletedPartialSnapshot(event) {

package/node_modules/@maka/storage/dist/sqlite-session-catalog-query.js

@@ -49,6 +49,7 @@ export function buildSqliteSessionCatalogPageQuery(filter, cursor) {
         metadata.payload_json,
         metadata.metadata_version,
         metadata.committed_at,
+        metadata.archived_at,
         projection.activity_at,
         projection.last_message_preview
       FROM session_catalog_projection projection

package/node_modules/@maka/storage/dist/sqlite-session-metadata-schema.js

@@ -16,7 +16,7 @@
  * specific language governing permissions and limitations
  * under the License.
  */
-export const SQLITE_SESSION_METADATA_SCHEMA_VERSION = 40;
+export const SQLITE_SESSION_METADATA_SCHEMA_VERSION = 41;
 export const SQLITE_SESSION_MESSAGE_CHUNK_BYTES = 64 * 1024;
 export const SQLITE_SESSION_MESSAGE_CHUNK_MARKER = '{"$maka":"session-message-chunks-v1"}';
 export const SQLITE_AGENT_GRAPH_CONTROL_TABLES = [
@@ -32,6 +32,16 @@ export const SQLITE_AGENT_GRAPH_CONTROL_TABLES = [
     'agent_graph_supervisor_wake_attempts',
 ];
 const MIGRATIONS = new Map([
+    [
+        41,
+        `
+    -- When the Session last entered the archive, owned by the lifecycle
+    -- writer alone. Rows archived before this column existed keep NULL: the
+    -- time they were archived was never recorded, and neither committed_at nor
+    -- activity says when.
+    ALTER TABLE session_metadata ADD COLUMN archived_at INTEGER;
+  `,
+    ],
     [
         40,
         `
@@ -1370,13 +1380,15 @@ export function migrateSqliteSessionMetadataDatabase(db, options = {}) {
             const sql = MIGRATIONS.get(version);
             if (!sql)
                 throw new Error(`Missing SQLite session metadata migration ${version}`);
-            // Versions 32, 35, and 37 each add one column, and the post-merge convergence
-            // path can replay them onto a database that already carries the current
-            // table shape. SQLite has no `ADD COLUMN IF NOT EXISTS`, so the guards
-            // live here.
+            // Versions 32, 35, 37, and 41 each add one column, and the post-merge
+            // convergence path can replay them onto a database that already carries
+            // the current table shape. SQLite has no `ADD COLUMN IF NOT EXISTS`, so
+            // the guards live here.
             const columnAlreadyPresent = (version === 32 && hasColumn(db, 'message_admissions', 'submitted_intent_json')) ||
                 (version === 35 && hasColumn(db, 'message_admissions', 'skill_invocation_json')) ||
-                (version === 37 && hasColumn(db, 'cancelled_message_admissions', 'cancellation_claim_id'));
+                (version === 37 &&
+                    hasColumn(db, 'cancelled_message_admissions', 'cancellation_claim_id')) ||
+                (version === 41 && hasColumn(db, 'session_metadata', 'archived_at'));
             if (!columnAlreadyPresent) {
                 db.exec(sql);
             }

package/node_modules/@maka/storage/dist/sqlite-session-metadata-store.js

@@ -740,6 +740,7 @@ export class SqliteSessionMetadataStore {
           metadata.payload_json,
           metadata.metadata_version,
           metadata.committed_at,
+          metadata.archived_at,
           projection.activity_at,
           projection.last_message_preview
         FROM session_catalog_projection projection
@@ -954,6 +955,7 @@ export class SqliteSessionMetadataStore {
           metadata.payload_json,
           metadata.metadata_version,
           metadata.committed_at,
+          metadata.archived_at,
           COALESCE(projection.activity_at, 0) AS activity_at,
           projection.last_message_preview
         FROM session_metadata metadata
@@ -3307,7 +3309,10 @@ export class SqliteSessionMetadataStore {
         this.assertOpen();
         const identities = uniqueVersionedSessionIdentities(sessions);
         return this.transaction(() => {
-            const records = identities.map(({ sessionId, expectedVersion }) => this.setArchivedSync(sessionId, expectedVersion, isArchived));
+            // One instant for the whole set, so a family archived together reads as
+            // archived together.
+            const archivedAt = this.now();
+            const records = identities.map(({ sessionId, expectedVersion }) => this.setArchivedSync(sessionId, expectedVersion, isArchived, archivedAt));
             if (isArchived)
                 this.deleteGoalAuthorities(identities);
             return records;
@@ -3349,7 +3354,7 @@ export class SqliteSessionMetadataStore {
             }
             const deletedAt = this.now();
             for (const { sessionId, expectedVersion } of archiveIdentities) {
-                this.setArchivedSync(sessionId, expectedVersion, true);
+                this.setArchivedSync(sessionId, expectedVersion, true, deletedAt);
             }
             for (const { sessionId } of present) {
                 const deleted = this.db
@@ -3570,7 +3575,7 @@ export class SqliteSessionMetadataStore {
         }, sessionId);
         return this.persistHeaderSync(sessionId, current, next, options);
     }
-    setArchivedSync(sessionId, expectedVersion, isArchived) {
+    setArchivedSync(sessionId, expectedVersion, isArchived, archivedAt) {
         const current = this.readRecordSync(sessionId);
         if (!current)
             throw new SessionNotFoundError(sessionId);
@@ -3578,7 +3583,13 @@ export class SqliteSessionMetadataStore {
             throw new SessionMetadataVersionConflictError(sessionId, expectedVersion, current.metadataVersion);
         }
         const next = normalizeSessionHeader({ ...current.header, isArchived }, sessionId);
-        return this.persistHeaderSync(sessionId, current, next, { skipNoop: true });
+        // A Session already in the requested state is a no-op below, so an
+        // archived Session keeps the time it was first archived; only a real
+        // transition writes the column. Every other writer leaves it alone.
+        return this.persistHeaderSync(sessionId, current, next, {
+            skipNoop: true,
+            archivedAt: isArchived ? archivedAt : null,
+        });
     }
     persistHeaderSync(sessionId, current, next, options = {}) {
         if (next.id !== sessionId) {
@@ -3610,10 +3621,11 @@ export class SqliteSessionMetadataStore {
           llm_connection_slug = ?,
           model = ?,
           metadata_version = ?,
-          committed_at = ?
+          committed_at = ?,
+          archived_at = CASE WHEN ? = 1 THEN ? ELSE archived_at END
         WHERE session_id = ? AND metadata_version = ?
       `)
-            .run(JSON.stringify(next), next.createdAt, next.lastMessageAt ?? null, next.name, booleanInteger(next.isFlagged), booleanInteger(next.isArchived), next.parentSessionId ?? null, next.subagentParent?.parentSessionId ?? null, next.revisionRootSessionId ?? null, next.revisionIndex ?? null, booleanInteger(next.hasUnread), next.backend, next.llmConnectionSlug, next.model, metadataVersion, committedAt, sessionId, current.metadataVersion);
+            .run(JSON.stringify(next), next.createdAt, next.lastMessageAt ?? null, next.name, booleanInteger(next.isFlagged), booleanInteger(next.isArchived), next.parentSessionId ?? null, next.subagentParent?.parentSessionId ?? null, next.revisionRootSessionId ?? null, next.revisionIndex ?? null, booleanInteger(next.hasUnread), next.backend, next.llmConnectionSlug, next.model, metadataVersion, committedAt, options.archivedAt === undefined ? 0 : 1, options.archivedAt ?? null, sessionId, current.metadataVersion);
         if (updated.changes !== 1) {
             throw new SessionMetadataConflictError(`Session metadata compare-and-set failed: ${sessionId}`);
         }
@@ -4495,12 +4507,22 @@ function decodeCatalogRecord(row) {
         throw new Error(`Invalid SQLite Session catalog activity for ${row.session_id}`);
     }
     const lastMessagePreview = decodeCatalogPreview(row.last_message_preview, row.session_id);
+    const archivedAt = decodeCatalogArchivedAt(row.archived_at, row.session_id);
     return {
         ...decodeRecord(row),
         activityAt: row.activity_at,
         ...(lastMessagePreview === undefined ? {} : { lastMessagePreview }),
+        ...(archivedAt === undefined ? {} : { archivedAt }),
     };
 }
+function decodeCatalogArchivedAt(value, sessionId) {
+    if (value === null || value === undefined)
+        return undefined;
+    if (typeof value !== 'number' || !Number.isSafeInteger(value) || value < 0) {
+        throw new Error(`Invalid SQLite Session archive time for ${sessionId}`);
+    }
+    return value;
+}
 function decodeCatalogPreview(value, sessionId) {
     if (value === null || value === undefined)
         return undefined;