maka-agent 0.2.0-dev.23.20260906 → 0.2.0-dev.24.20260907

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

@@ -28,7 +28,7 @@ import { isOrchestrationMode } from '@maka/core/orchestration';
 import { decodePersistedPermissionMode, isPermissionMode } from '@maka/core/permission';
 import { isSubagentWorkspaceBinding } from '@maka/core/subagent-workspace';
 import { isSessionToolProfile, } from '@maka/core/session';
-import { isVisibleSessionMessage, lastMessagePreviewForMessages, latestVisibleMessageAt, projectSessionCatalogMessages, } from './session-message-projection.js';
+import { projectSessionCatalogMessages } from './session-message-projection.js';
 export { projectSessionCatalogMessages };
 const SESSION_ID_PATTERN = /^[A-Za-z0-9_-]{1,128}$/;
 export function isSafeSessionId(sessionId) {
@@ -50,17 +50,6 @@ export class SessionNotFoundError extends Error {
 export function isSessionNotFoundError(error) {
     return error instanceof SessionNotFoundError;
 }
-export class SessionReadMarkerMessageNotFoundError extends Error {
-    sessionId;
-    messageId;
-    name = 'SessionReadMarkerMessageNotFoundError';
-    code = 'session_read_marker_message_not_found';
-    constructor(sessionId, messageId) {
-        super(`Session read marker message does not exist: ${messageId}`);
-        this.sessionId = sessionId;
-        this.messageId = messageId;
-    }
-}
 export const EXTERNAL_SESSION_IMPORT_LOOKUP_MAX_SOURCE_IDS = 256;
 export const EXTERNAL_SESSION_IMPORT_LOOKUP_MAX_RECENT_SESSION_IDS = 16;
 export function createSessionStore(workspaceRoot) {
@@ -303,6 +292,10 @@ class SqliteSessionStore {
         await this.ensureReady();
         return this.metadata.listSandboxBoundaryRestartClosures(sessionId);
     }
+    async hasExplicitSandboxBoundaryDenial(identities) {
+        await this.ensureReady();
+        return this.metadata.hasExplicitSandboxBoundaryDenial(identities);
+    }
     async settleSandboxBoundaryRequest(input) {
         await this.ensureReady();
         return this.metadata.settleSandboxBoundaryRequest(input);
@@ -313,29 +306,9 @@ class SqliteSessionStore {
     }
     async list(filter) {
         await this.ensureReady();
-        const records = (await this.metadata.list(filter, 'ordinary')).filter((record) => record.header.conversationCopy?.state !== 'preparing');
-        const withPreviews = [];
-        for (const record of records) {
-            const previewMessages = await this.metadata.readPreviewMessages(record.header.id);
-            withPreviews.push({ record, previewMessages });
-        }
-        withPreviews.sort((a, b) => {
-            const aLastMessageAt = maxTimestamp(a.record.header.lastMessageAt, latestVisibleMessageAt(a.previewMessages));
-            const bLastMessageAt = maxTimestamp(b.record.header.lastMessageAt, latestVisibleMessageAt(b.previewMessages));
-            const tsDelta = (bLastMessageAt ?? 0) - (aLastMessageAt ?? 0);
-            return tsDelta !== 0 ? tsDelta : a.record.header.id.localeCompare(b.record.header.id);
-        });
-        const summaries = [];
-        for (let index = 0; index < withPreviews.length; index += 1) {
-            const { record, previewMessages } = withPreviews[index];
-            const { header } = record;
-            let messages = previewMessages.slice(-10);
-            if (index < 3) {
-                messages = (await this.metadata.readMessages(header.id)).slice(-10);
-            }
-            summaries.push(toSummary(header, messages));
-        }
-        return summaries;
+        return (await this.metadata.list(filter, 'ordinary'))
+            .filter((record) => record.header.conversationCopy?.state !== 'preparing')
+            .map((record) => toCatalogSummary(record.header, record.lastMessagePreview));
     }
     async listCatalogPage(filter, cursor, limit, expectedRevision) {
         await this.ensureCatalogProjectionReadable();
@@ -360,11 +333,7 @@ class SqliteSessionStore {
         };
     }
     async listForRecovery() {
-        const headers = await this.listHeaders();
-        for (const header of headers) {
-            await this.metadata.readMessagesForRecovery(header.id);
-        }
-        return headers;
+        return this.listHeaders();
     }
     async listHeaders() {
         await this.ensureReady();
@@ -395,34 +364,14 @@ class SqliteSessionStore {
         await this.ensureReady();
         return this.metadata.readMessages(sessionId);
     }
-    async readTranscriptPageSnapshot(sessionId, request) {
-        await this.ensureReady();
-        return this.metadata.readTranscriptPage(sessionId, request);
-    }
     async readTranscriptMessagesSnapshot(sessionId, request) {
         await this.ensureReady();
         return this.metadata.readTranscriptMessages(sessionId, request);
     }
-    async readTranscriptRecordsSnapshot(sessionId, request) {
-        await this.ensureReady();
-        return this.metadata.readTranscriptRecords(sessionId, request);
-    }
     async readTranscriptHighWaterSnapshot(sessionId) {
         await this.ensureReady();
         return this.metadata.readTranscriptHighWater(sessionId);
     }
-    async readTurnContributionsSnapshot(sessionId, throughSequence, position, maxContributions) {
-        await this.ensureReady();
-        return this.metadata.readTurnContributions(sessionId, throughSequence, position, maxContributions);
-    }
-    async readTurnLandmarksSnapshot(sessionId, maxLandmarks) {
-        await this.ensureReady();
-        return this.metadata.readTurnLandmarks(sessionId, maxLandmarks);
-    }
-    async readMessagesForRecovery(sessionId) {
-        await this.ensureReady();
-        return this.metadata.readMessagesForRecovery(sessionId);
-    }
     async listTurnsSnapshot(sessionId) {
         return deriveTurnRecords(await this.readMessagesSnapshot(sessionId));
     }
@@ -432,6 +381,10 @@ class SqliteSessionStore {
     async readMessages(sessionId) {
         return this.readMessagesSnapshot(sessionId);
     }
+    async readMessagesAfter(sessionId, request) {
+        await this.ensureReady();
+        return this.metadata.readMessagesAfter(sessionId, request);
+    }
     async listTurns(sessionId) {
         return deriveTurnRecords(await this.readMessages(sessionId));
     }
@@ -446,6 +399,11 @@ class SqliteSessionStore {
         for (const listener of this.transcriptChangeListeners)
             listener(sessionId);
     }
+    /** @see SqliteSessionMetadataStore.commitMessageCatalogProjection */
+    async commitMessageCatalogProjection(sessionId, message) {
+        await this.ensureReady();
+        await this.metadata.commitMessageCatalogProjection(sessionId, message);
+    }
     async commitMessageAdmission(admission) {
         await this.ensureReady();
         return this.metadata.commitMessageAdmission(admission);
@@ -503,33 +461,6 @@ class SqliteSessionStore {
         await this.ensureReady();
         return projectHeaderSnapshot(await this.metadata.updateSessionConfiguration(sessionId, input));
     }
-    async markSessionReadThroughMessage(sessionId, messageId) {
-        for (let attempt = 0; attempt < 3; attempt += 1) {
-            const record = await this.readHeaderRecordSnapshot(sessionId);
-            const messages = await this.readMessagesSnapshot(sessionId);
-            const visibleMessages = messages.filter(isVisibleSessionMessage);
-            const targetIndex = visibleMessages.findIndex((message) => message.id === messageId);
-            if (targetIndex < 0) {
-                throw new SessionReadMarkerMessageNotFoundError(sessionId, messageId);
-            }
-            const currentIndex = record.header.lastReadMessageId === undefined
-                ? -1
-                : visibleMessages.findIndex((message) => message.id === record.header.lastReadMessageId);
-            const hasUnread = targetIndex < visibleMessages.length - 1;
-            if (targetIndex < currentIndex ||
-                (targetIndex === currentIndex && record.header.hasUnread === hasUnread)) {
-                return record;
-            }
-            try {
-                return await this.updateHeaderVersioned(sessionId, { lastReadMessageId: messageId, hasUnread }, record.revision);
-            }
-            catch (error) {
-                if (!(error instanceof SessionMetadataVersionConflictError) || attempt === 2)
-                    throw error;
-            }
-        }
-        throw new Error('Session read marker retry loop did not terminate');
-    }
     async probeSessionRemoval(sessionId) {
         await this.ensureReady();
         return projectRemovalProbe(await this.metadata.probeRemoval(sessionId));
@@ -678,6 +609,11 @@ function buildSessionHeader(workspaceRoot, input, sessionId = randomUUID(), conv
         collaborationMode: input.collaborationMode ?? 'agent',
         orchestrationMode: input.orchestrationMode ?? 'default',
         ...(input.thinkingLevel !== undefined ? { thinkingLevel: input.thinkingLevel } : {}),
+        // Born on the ledger: a Session created here records its execution facts as
+        // RuntimeEvents from its first turn, so there is no transcript to convert.
+        // Only an imported transcript (staged at 0) and a Session written before
+        // this field existed have anything for the converter to do.
+        transcriptLedgerVersion: 1,
         schemaVersion: 1,
     };
     assertValidSessionLineage(header);
@@ -886,10 +822,8 @@ function projectStableSessionCreateProbe(probe) {
         ? { kind: 'existing', record: projectHeaderSnapshot(probe.record) }
         : probe;
 }
-function toSummary(header, messages = []) {
-    const preview = lastMessagePreviewForMessages(messages);
-    const derivedLastMessageAt = latestVisibleMessageAt(messages);
-    const lastMessageAt = maxTimestamp(header.lastMessageAt, derivedLastMessageAt);
+function toSummary(header) {
+    const lastMessageAt = header.lastMessageAt;
     return {
         id: header.id,
         cwd: header.cwd,
@@ -900,7 +834,6 @@ function toSummary(header, messages = []) {
         labels: header.labels,
         hasUnread: header.hasUnread,
         lastMessageAt,
-        ...(preview ? { lastMessagePreview: preview } : {}),
         status: header.status,
         ...(header.blockedReason ? { blockedReason: header.blockedReason } : {}),
         ...(header.statusUpdatedAt !== undefined ? { statusUpdatedAt: header.statusUpdatedAt } : {}),
@@ -939,13 +872,6 @@ function toCatalogSummary(header, lastMessagePreview) {
         ...(lastMessagePreview === undefined ? {} : { lastMessagePreview }),
     };
 }
-function maxTimestamp(left, right) {
-    if (left === undefined)
-        return right;
-    if (right === undefined)
-        return left;
-    return Math.max(left, right);
-}
 function normalizeSessionName(name) {
     return name === 'New Session' ? DEFAULT_SESSION_NAME : name;
 }

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

@@ -68,13 +68,20 @@ class SqliteArtifactMetadataRepository {
             }
         });
     }
-    readUpgradeOrphanPaths() {
+    readUpgradeOrphanPaths(after, limit) {
         this.assertOpen();
         const rows = this.#lease.database
-            .prepare('SELECT relative_path FROM artifact_upgrade_orphan_paths ORDER BY relative_path')
-            .all();
+            .prepare(`SELECT relative_path FROM artifact_upgrade_orphan_paths
+        WHERE relative_path > ? ORDER BY relative_path LIMIT ?`)
+            .all(after, limit);
         return rows.map((row) => row.relative_path);
     }
+    hasRelativePath(relativePath) {
+        this.assertOpen();
+        return Boolean(this.#lease.database
+            .prepare('SELECT 1 FROM artifact_records WHERE relative_path = ?')
+            .get(relativePath));
+    }
     forgetUpgradeOrphanPaths(relativePaths) {
         this.assertOpen();
         this.#lease.transaction('write', () => {

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

@@ -253,7 +253,7 @@ export class SqliteContextOffloadStore {
         return this.#runManagedValueMutation(async () => {
             this.#assertOpen();
             if (this.#hasPendingFileDeletions()) {
-                await this.#drainPendingFileDeletions(input.maxBlobs);
+                await this.#drainPendingFileDeletions(input.maxBlobs, input.maxBytes);
                 return {
                     deletedBlobs: 0,
                     deletedBytes: 0,
@@ -262,7 +262,7 @@ export class SqliteContextOffloadStore {
             }
             const collected = this.#writeTransaction(() => {
                 const rows = this.#database
-                    .prepare(`SELECT c.blob_id, b.size_bytes, b.storage_kind, b.payload
+                    .prepare(`SELECT c.blob_id, b.size_bytes, b.storage_kind
            FROM context_gc_candidates c INDEXED BY context_gc_candidates_eligible
            JOIN context_blobs b ON b.blob_id = c.blob_id
            WHERE c.unreferenced_at < ?
@@ -272,6 +272,8 @@ export class SqliteContextOffloadStore {
                 const selected = [];
                 let deletedBytes = 0;
                 let inlineDeletedBytes = 0;
+                // Admit by metadata before SQLite materializes legacy inline BLOBs.
+                const readValue = this.#database.prepare('SELECT storage_kind, size_bytes, payload FROM context_blobs WHERE blob_id = ?');
                 for (const row of rows) {
                     if (selected.length === input.maxBlobs)
                         break;
@@ -279,15 +281,21 @@ export class SqliteContextOffloadStore {
                     if (!blobId || !isNonNegativeSafeInteger(row.size_bytes)) {
                         throw new Error('Invalid context garbage candidate');
                     }
-                    const value = decodeBlobValue(row, Buffer.from(blobId).toString('hex'));
-                    if (!value)
-                        throw new Error('Invalid context garbage candidate value');
                     if (exceedsLimit(deletedBytes, row.size_bytes, input.maxBytes)) {
                         if (selected.length === 0) {
                             throw new Error(`Context garbage byte limit ${input.maxBytes} cannot fit eligible blob of ${row.size_bytes} bytes`);
                         }
                         break;
                     }
+                    const stored = readValue.get(blobId);
+                    if (!stored ||
+                        stored.size_bytes !== row.size_bytes ||
+                        stored.storage_kind !== row.storage_kind) {
+                        throw new Error('Invalid context garbage candidate metadata');
+                    }
+                    const value = decodeBlobValue(stored, Buffer.from(blobId).toString('hex'));
+                    if (!value)
+                        throw new Error('Invalid context garbage candidate value');
                     deletedBytes = addSafeInteger(deletedBytes, row.size_bytes, 'Collected context bytes');
                     selected.push({
                         blobId,
@@ -329,7 +337,7 @@ export class SqliteContextOffloadStore {
                     hasMore: rows.length > selected.length,
                 };
             });
-            await this.#drainPendingFileDeletions(input.maxBlobs);
+            await this.#drainPendingFileDeletions(input.maxBlobs, input.maxBytes);
             return {
                 ...collected,
                 hasMore: collected.hasMore || this.#hasPendingFileDeletions(),
@@ -714,11 +722,19 @@ export class SqliteContextOffloadStore {
             }
         });
     }
-    async #drainPendingFileDeletions(limit) {
+    async #drainPendingFileDeletions(limit, maxBytes) {
         const rows = this.#database
-            .prepare('SELECT locator FROM context_file_deletions ORDER BY enqueued_at, locator LIMIT ?')
+            .prepare('SELECT locator, size_bytes FROM context_file_deletions ORDER BY enqueued_at, locator LIMIT ?')
             .all(limit);
+        let bytes = 0;
         for (const row of rows) {
+            const size = readNonNegativeInteger(row.size_bytes, 'Pending context file deletion bytes');
+            if (exceedsLimit(bytes, size, maxBytes)) {
+                if (bytes === 0)
+                    throw new Error('Context garbage byte limit cannot fit pending file');
+                break;
+            }
+            bytes += size;
             const locator = decodeManagedFileLocator(row.locator);
             if (!locator)
                 throw new Error('Invalid pending context file deletion locator');

package/node_modules/@maka/storage/dist/sqlite-core-execution-schema.js

@@ -16,7 +16,8 @@
  * specific language governing permissions and limitations
  * under the License.
  */
-export const SQLITE_CORE_EXECUTION_SCHEMA_VERSION = 8;
+export const SQLITE_CORE_EXECUTION_SCHEMA_VERSION = 9;
+export const MODEL_PROJECTION_TARGET_SQL = "CASE WHEN json_valid(record_json) THEN CASE WHEN json_type(record_json, '$.data.transition.target.runtimeEventId') = 'text' THEN nullif(json_extract(record_json, '$.data.transition.target.runtimeEventId'), '') WHEN json_type(record_json, '$.data.runtimeEventId') = 'text' THEN nullif(json_extract(record_json, '$.data.runtimeEventId'), '') END END";
 export function migrateSqliteCoreExecutionDatabase(db) {
     db.exec(`
     CREATE TABLE IF NOT EXISTS core_agent_runs (
@@ -50,6 +51,11 @@ export function migrateSqliteCoreExecutionDatabase(db) {
     CREATE INDEX IF NOT EXISTS core_agent_run_events_type_sequence
       ON core_agent_run_events(event_type, session_id, run_id, sequence);
 
+    CREATE INDEX IF NOT EXISTS core_model_projection_target
+      ON core_agent_run_events(session_id,
+        ${MODEL_PROJECTION_TARGET_SQL}
+      ) WHERE event_type = 'model_projection_transition_recorded';
+
     CREATE TABLE IF NOT EXISTS core_agent_run_projections (
       session_id TEXT NOT NULL,
       event_type TEXT NOT NULL,

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

@@ -18,8 +18,9 @@
  */
 import { decodePersistedLegacyRunHeader, invocationOpeningFromLegacyRunHeader, } from './legacy-run-header.js';
 import { encodeCanonicalRuntimeEvent } from '@maka/core/canonical-runtime-event';
+import { TERMINAL_RUNTIME_EVENT_SQL } from './runtime-transcript-query.js';
 import { buildInvocationOpenedEvent, buildSyntheticTerminalRuntimeEvent, } from '@maka/core/runtime-invocation';
-export const SQLITE_RUNTIME_SCHEMA_VERSION = 16;
+export const SQLITE_RUNTIME_SCHEMA_VERSION = 18;
 export const RUNTIME_RECOVERY_AUTHORITY_CAPABILITY = 'runtime_recovery_authority';
 export const RUNTIME_RECOVERY_AUTHORITY_CAPABILITY_VERSION = 1;
 export const RUNTIME_CONTINUATION_AUTHORITY_CAPABILITY = 'runtime_continuation_authority';
@@ -567,6 +568,48 @@ const MIGRATIONS = new Map([
     ALTER TABLE runtime_continuation_claims_v16 RENAME TO runtime_continuation_claims;
     `,
     ],
+    [
+        17,
+        `
+    -- Handoff replaces a physical attempt, not the admitted logical Turn.
+    -- Keep physical identities and each source boundary exclusive.
+    CREATE TABLE runtime_continuation_claims_v17 (
+      claim_id TEXT PRIMARY KEY,
+      source_session_id TEXT NOT NULL,
+      source_invocation_id TEXT NOT NULL,
+      source_run_id TEXT NOT NULL,
+      source_turn_id TEXT NOT NULL,
+      source_event_high_water INTEGER NOT NULL CHECK (source_event_high_water > 0),
+      source_prefix_digest TEXT NOT NULL,
+      boundary_digest TEXT NOT NULL UNIQUE,
+      boundary_json TEXT NOT NULL,
+      provider_projection_version INTEGER NOT NULL CHECK (provider_projection_version IN (1, 2)),
+      provider_replay_digest TEXT NOT NULL,
+      target_session_id TEXT NOT NULL,
+      target_invocation_id TEXT NOT NULL UNIQUE,
+      target_run_id TEXT NOT NULL UNIQUE,
+      target_turn_id TEXT NOT NULL,
+      target_opening_json TEXT NOT NULL,
+      claimed_at INTEGER NOT NULL,
+      start_event_id TEXT UNIQUE REFERENCES runtime_events(event_id) ON DELETE CASCADE,
+      start_kind TEXT CHECK (start_kind IS NULL OR start_kind IN ('runtime_admission', 'claim_repair')),
+      protocol_version INTEGER NOT NULL CHECK (protocol_version = 1),
+      UNIQUE (source_session_id, source_run_id, source_event_high_water, source_prefix_digest)
+    );
+    INSERT INTO runtime_continuation_claims_v17 SELECT * FROM runtime_continuation_claims;
+    DROP TABLE runtime_continuation_claims;
+    ALTER TABLE runtime_continuation_claims_v17 RENAME TO runtime_continuation_claims;
+    CREATE UNIQUE INDEX runtime_continuation_fresh_turn
+      ON runtime_continuation_claims(target_session_id, target_turn_id)
+      WHERE json_extract(target_opening_json, '$.source.kind') <> 'handoff';
+    `,
+    ],
+    [
+        18,
+        `
+    CREATE INDEX IF NOT EXISTS runtime_events_terminal ON runtime_events(invocation_id, event_seq) WHERE ${TERMINAL_RUNTIME_EVENT_SQL};
+  `,
+    ],
 ]);
 /**
  * Data migrations that a SQL statement cannot express, applied inside the same