maka-agent 0.2.1-dev.91.20261018 → 0.2.2-dev.97.20261024

package/node_modules/@maka/storage/dist/event-wait-bridge.js

@@ -0,0 +1,336 @@
+/*
+ * 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.
+ */
+import { createHash } from 'node:crypto';
+import { isDeepStrictEqual as equal } from 'node:util';
+import { decodeEventWaitRecord } from '@maka/core/event-wait';
+import { decodeGoalAuthorityRecord, sameGoalControlLease, } from '@maka/core/goal';
+import { readLogicalRuntimeExecution } from '@maka/core/runtime-logical-execution';
+export function eventWaitProvenance(wait) {
+    if (wait.status !== 'resolved' && wait.status !== 'expired')
+        throw new Error('Wait has no result');
+    return {
+        waitId: wait.waitId,
+        deliveryKey: wait.deliveryKey,
+        sourceTurnId: wait.sourceTurnId,
+        sourceToolCallId: wait.sourceToolCallId,
+        generation: wait.goalControlLease.generation,
+        outcome: wait.status === 'expired' ? 'expired' : wait.resolution.outcome,
+        resultDigest: `sha256:${createHash('sha256')
+            .update(JSON.stringify(wait.status === 'expired' ? { expiredAt: wait.expiredAt } : wait.resolution))
+            .digest('hex')}`,
+    };
+}
+function owningGoal(goal, wait) {
+    if (!goal ||
+        goal.record.goal.sessionId !== wait.sessionId ||
+        !sameGoalControlLease(goal.record.controlLease, wait.goalControlLease) ||
+        !['active', 'waiting'].includes(goal.record.goal.status))
+        throw new Error('Event wait Goal is unavailable');
+    return goal;
+}
+function update(goal, record) {
+    return {
+        authorityRevision: goal.authorityRevision + 1,
+        record: decodeGoalAuthorityRecord(record),
+    };
+}
+/** Authenticate immutable handoff membership before the joint write. The write
+ * rechecks the admission and that the physical source has not ended or sealed. */
+export async function readGoalWaitRootExecution(runtime, input, source) {
+    if (!source)
+        return undefined;
+    const root = { sessionId: source.sessionId, turnId: source.turnId, runId: source.runId };
+    if (equal(root, input.sourceExecution))
+        return root;
+    const logical = await readLogicalRuntimeExecution(runtime, root);
+    if (!logical ||
+        logical.pendingHandoff ||
+        logical.tip.runId !== input.sourceExecution.runId ||
+        logical.tip.sessionId !== input.sourceExecution.sessionId ||
+        logical.tip.turnId !== input.sourceExecution.turnId)
+        throw new Error('Invalid source execution for wait registration');
+    return root;
+}
+/** A later user Turn may arrive while a completed ordinary Goal Turn awaits
+ * evaluation. Authenticate its logical termination before replacing that slot;
+ * a handoff seal alone does not finish the execution. */
+export async function readCompletedGoalWaitExecution(runtime, current, source) {
+    if (!current || equal(current.execution, source))
+        return undefined;
+    const logical = await readLogicalRuntimeExecution(runtime, current.execution);
+    if (!logical || logical.pendingHandoff || logical.tip.terminalEvent?.status !== 'completed')
+        return undefined;
+    return current.execution;
+}
+/** Only a current ordinary checkpoint still owns an outstanding settlement.
+ * Stale checkpoints and revoked control generations must not be charged again. */
+export function goalWaitPredecessor(record, sourceTurnId) {
+    const current = record.currentExecution;
+    return record.goal.status === 'active' &&
+        current &&
+        current.execution.turnId !== sourceTurnId &&
+        current.checkpoint.goalId === record.goal.id &&
+        current.checkpoint.revision === record.goal.revision &&
+        sameGoalControlLease(current.controlLease, record.controlLease)
+        ? current
+        : undefined;
+}
+export function registerGoalWait(input, current, existing, source, logicalSource, completedExecution) {
+    const record = decodeEventWaitRecord(input.record);
+    const goal = owningGoal(current, record);
+    if (existing) {
+        const a = existing.record;
+        if (!equal([
+            record.waitId,
+            record.sessionId,
+            record.goalControlLease,
+            record.sourceTurnId,
+            record.sourceToolCallId,
+            record.resource,
+            record.condition,
+            record.createdAt,
+            record.deadlineAt,
+        ], [
+            a.waitId,
+            a.sessionId,
+            a.goalControlLease,
+            a.sourceTurnId,
+            a.sourceToolCallId,
+            a.resource,
+            a.condition,
+            a.createdAt,
+            a.deadlineAt,
+        ]))
+            throw new Error('Conflicting wait registration');
+        if (goal.record.activeEventWait?.waitId !== record.waitId ||
+            goal.record.activeEventWait.reason !== input.reason ||
+            !equal(goal.record.activeEventWait.sourceExecution, input.sourceExecution))
+            throw new Error('Wait no longer owns the Goal');
+        return { wait: existing, goal };
+    }
+    if (record.status !== 'waiting' ||
+        record.delivery ||
+        record.observation ||
+        goal.record.goal.revision !== input.expectedGoalRevision ||
+        goal.record.activeEventWait ||
+        goal.record.pendingContinuation?.eventWait ||
+        !source ||
+        source.sessionId !== record.sessionId ||
+        source.turnId !== record.sourceTurnId ||
+        input.sourceExecution.sessionId !== record.sessionId ||
+        input.sourceExecution.turnId !== record.sourceTurnId ||
+        !equal(logicalSource, {
+            sessionId: record.sessionId,
+            turnId: record.sourceTurnId,
+            runId: source.runId,
+        }) ||
+        (goal.record.currentExecution &&
+            !equal(goal.record.currentExecution.execution, logicalSource) &&
+            !equal(goal.record.currentExecution.execution, completedExecution)))
+        throw new Error('Invalid source execution for wait registration');
+    const predecessor = goalWaitPredecessor(goal.record, record.sourceTurnId);
+    const settlement = input.previousTurnSettlement;
+    if (predecessor
+        ? !settlement ||
+            !equal(settlement.execution, predecessor.execution) ||
+            settlement.goal.id !== goal.record.goal.id ||
+            settlement.goal.sessionId !== record.sessionId ||
+            settlement.goal.revision !== input.expectedGoalRevision + 1 ||
+            settlement.goal.status !== 'active'
+        : settlement !== undefined)
+        throw new Error('Previous Goal Turn settlement does not match');
+    // Explicit waiting replaces the old ordinary drive in this same transaction.
+    // Wake legacy waiting without charging work or changing its control generation.
+    const nextGoal = settlement?.goal ??
+        (goal.record.goal.status === 'waiting'
+            ? { ...goal.record.goal, status: 'active', revision: goal.record.goal.revision + 1 }
+            : goal.record.goal);
+    const checkpoint = { goalId: nextGoal.id, revision: nextGoal.revision };
+    return {
+        wait: { authorityRevision: 0, record },
+        goal: update(goal, {
+            ...goal.record,
+            goal: nextGoal,
+            pendingContinuation: null,
+            currentExecution: {
+                execution: logicalSource,
+                checkpoint,
+                controlLease: goal.record.controlLease,
+            },
+            activeEventWait: {
+                waitId: record.waitId,
+                sourceExecution: input.sourceExecution,
+                controlLease: record.goalControlLease,
+                reason: input.reason,
+                settled: false,
+            },
+        }),
+    };
+}
+export function assertSourceYield(wait, source, events) {
+    if (!events.some((e) => e.sessionId === wait.sessionId &&
+        e.runId === source.runId &&
+        e.turnId === wait.sourceTurnId &&
+        e.status === 'completed' &&
+        e.actions?.stateDelta?.stopReason === 'event_wait'))
+        throw new Error('Source Turn has no durable event-wait yield termination');
+}
+export function settleGoalWait(input, current, wait, events) {
+    const goal = owningGoal(current, wait.record), gate = goal.record.activeEventWait;
+    if (!gate || gate.waitId !== input.waitId || input.sessionId !== wait.record.sessionId)
+        throw new Error('Wait gate changed');
+    assertSourceYield(wait.record, gate.sourceExecution, events);
+    if (gate.settled)
+        return { goal, wait };
+    if (goal.record.goal.revision !== input.expectedGoalRevision ||
+        input.goal.revision !== input.expectedGoalRevision + 1 ||
+        input.goal.id !== goal.record.goal.id ||
+        input.goal.sessionId !== input.sessionId)
+        throw new Error('Wait settlement revision changed');
+    if (!['active', 'waiting'].includes(input.goal.status)) {
+        const { activeEventWait: _gate, ...record } = goal.record;
+        return {
+            wait: suppressGoalWait(wait, wait.record.updatedAt),
+            goal: update(goal, {
+                ...record,
+                goal: input.goal,
+                currentExecution: null,
+                pendingContinuation: null,
+            }),
+        };
+    }
+    return {
+        wait,
+        goal: update(goal, {
+            ...goal.record,
+            goal: input.goal,
+            currentExecution: null,
+            pendingContinuation: null,
+            activeEventWait: { ...gate, settled: true },
+        }),
+    };
+}
+export function queueGoalWait(input, current, wait, events) {
+    const goal = owningGoal(current, wait.record), gate = goal.record.activeEventWait;
+    if (!gate?.settled ||
+        gate.waitId !== input.waitId ||
+        goal.record.currentExecution ||
+        wait.record.delivery ||
+        input.sessionId !== wait.record.sessionId)
+        throw new Error('Wait is not ready for delivery');
+    assertSourceYield(wait.record, gate.sourceExecution, events);
+    if (goal.record.pendingContinuation) {
+        if (!equal(goal.record.pendingContinuation, input.pending))
+            throw new Error('Conflicting event continuation');
+        return { goal, wait };
+    }
+    if (goal.record.goal.revision !== input.expectedGoalRevision ||
+        !input.pending.eventWait ||
+        !equal(input.pending.eventWait.provenance, eventWaitProvenance(wait.record)))
+        throw new Error('Event continuation result changed');
+    assertGoalWaitBudget(goal.record.goal);
+    return { wait, goal: update(goal, { ...goal.record, pendingContinuation: input.pending }) };
+}
+export function assertGoalWaitBudget(goal) {
+    if (goal.iterations >= goal.maxIterations ||
+        (goal.tokenBudget !== undefined &&
+            !goal.tokensBaselinePending &&
+            goal.tokensNow - goal.tokensAtStart >= goal.tokenBudget))
+        throw new Error('Event wait Goal budget exhausted');
+}
+export function admitGoalWait(admission, current, wait) {
+    const goal = owningGoal(current, wait.record), pending = goal.record.pendingContinuation;
+    const event = pending?.eventWait;
+    if (admission.execution.kind !== 'goal' ||
+        !admission.execution.eventWait ||
+        !event ||
+        !pending ||
+        !goal.record.activeEventWait?.settled ||
+        goal.record.activeEventWait.waitId !== wait.record.waitId ||
+        wait.record.delivery ||
+        goal.record.currentExecution ||
+        !equal(event.execution, {
+            sessionId: admission.sessionId,
+            turnId: admission.turnId,
+            runId: admission.runId,
+        }) ||
+        event.userMessageId !== admission.userMessageId ||
+        !equal(admission.normalizedInput, { text: pending.prompt }) ||
+        admission.sourceMessages.length !== 0 ||
+        !equal(event.provenance, admission.execution.eventWait) ||
+        !equal(event.provenance, eventWaitProvenance(wait.record)) ||
+        admission.execution.goalId !== goal.record.goal.id)
+        throw new Error('Event wait admission changed');
+    assertGoalWaitBudget(goal.record.goal);
+    const { activeEventWait: _gate, ...record } = goal.record;
+    const at = Math.max(admission.admittedAt, wait.record.updatedAt);
+    return {
+        goal: update(goal, {
+            ...record,
+            pendingContinuation: null,
+            currentExecution: {
+                execution: event.execution,
+                checkpoint: pending.checkpoint,
+                controlLease: pending.controlLease,
+            },
+        }),
+        wait: {
+            authorityRevision: wait.authorityRevision + 1,
+            record: decodeEventWaitRecord({
+                ...wait.record,
+                updatedAt: at,
+                delivery: {
+                    kind: 'admitted',
+                    turnId: admission.turnId,
+                    runId: admission.runId,
+                    userMessageId: admission.userMessageId,
+                    at,
+                },
+            }),
+        },
+    };
+}
+export function suppressGoalWait(wait, at) {
+    if (wait.record.delivery)
+        return wait;
+    at = Math.max(at, wait.record.updatedAt);
+    const r = wait.record;
+    const reason = 'Goal wait cancelled or control generation ended';
+    const record = r.status === 'waiting' || r.status === 'resolved'
+        ? {
+            ...r,
+            status: 'cancelled',
+            updatedAt: at,
+            cancelledAt: at,
+            reason,
+            ...(r.status === 'resolved'
+                ? { priorResolution: { resolvedAt: r.resolvedAt, resolution: r.resolution } }
+                : {}),
+        }
+        : { ...r, updatedAt: at };
+    // Remove resolved-only fields when cancelling, retaining the immutable receipt explicitly.
+    if (r.status === 'resolved') {
+        delete record.resolvedAt;
+        delete record.resolution;
+    }
+    return {
+        authorityRevision: wait.authorityRevision + 1,
+        record: decodeEventWaitRecord({ ...record, delivery: { kind: 'suppressed', at, reason } }),
+    };
+}

package/node_modules/@maka/storage/dist/execution-stores.js

@@ -17,6 +17,7 @@
  * under the License.
  */
 import { openInteractiveEventWaitAuthorityForWrite, } from './event-wait-authority.js';
+import { SnapshotOperationGate } from './snapshot-operation-gate.js';
 import { createSqliteAgentRunStore, } from './agent-run-store.js';
 import { createSessionStore } from './session-store.js';
 import { assertStorageRootLease, assertStorageRootLeaseActive, runWithStorageRootLease, StorageRootAuthorityError, } from './root-authority.js';
@@ -102,6 +103,7 @@ async function createExecutionStoresForWrite(lease, provider) {
     let closed = false;
     let closeTask;
     const active = new Set();
+    const snapshotGate = new SnapshotOperationGate();
     const subscriptions = new Set();
     const run = (operation) => {
         if (closed)
@@ -109,7 +111,7 @@ async function createExecutionStoresForWrite(lease, provider) {
         const pending = runWithStorageRootLease(lease, kind, 'write', () => {
             if (closed)
                 throw invalidExecutionStores(kind, 'write');
-            return operation();
+            return snapshotGate.run(operation);
         });
         active.add(pending);
         void pending.finally(() => active.delete(pending)).catch(() => undefined);
@@ -167,6 +169,9 @@ async function createExecutionStoresForWrite(lease, provider) {
             extendSourceCooldown: (input) => run(async () => persistence.eventWaitStore.extendSourceCooldown(input)),
             reserveSourceDispatch: (input) => run(async () => persistence.eventWaitStore.reserveSourceDispatch(input)),
             completeSourceDispatch: (input) => run(async () => persistence.eventWaitStore.completeSourceDispatch(input)),
+            registerGoalWait: (input) => run(async () => persistence.eventWaitStore.registerGoalWait(input)),
+            settleGoalWait: (input) => run(async () => persistence.eventWaitStore.settleGoalWait(input)),
+            queueGoalWait: (input) => run(async () => persistence.eventWaitStore.queueGoalWait(input)),
             commit: (input) => run(async () => persistence.eventWaitStore.commit(input)),
             close: () => { },
         });
@@ -276,6 +281,37 @@ async function createExecutionStoresForWrite(lease, provider) {
         close: () => { },
     });
     const stores = {
+        ...(persistence.createSnapshotStatePreparer
+            ? {
+                snapshot: Object.freeze({
+                    runExclusive(operation) {
+                        if (closed)
+                            return Promise.reject(invalidExecutionStores(kind, 'write'));
+                        const pending = snapshotGate.exclusive(() => runWithStorageRootLease(lease, kind, 'write', async () => {
+                            if (closed)
+                                throw invalidExecutionStores(kind, 'write');
+                            const state = persistence.createSnapshotStatePreparer(lease);
+                            let scopeActive = true;
+                            try {
+                                return await operation({
+                                    prepareState: (input) => {
+                                        if (!scopeActive || closed)
+                                            return Promise.reject(invalidExecutionStores(kind, 'write'));
+                                        return state.prepareState(input);
+                                    },
+                                });
+                            }
+                            finally {
+                                scopeActive = false;
+                            }
+                        }));
+                        active.add(pending);
+                        void pending.finally(() => active.delete(pending)).catch(() => { });
+                        return pending;
+                    },
+                }),
+            }
+            : {}),
         interactionStore,
         graphControlStore,
         goalStore,
@@ -407,6 +443,7 @@ async function createExecutionStoresForWrite(lease, provider) {
                 }
                 : {}),
             scanRuntimeEvents: (sessionId, runId, budget, visit) => run(() => runtimeEventStore.scanRuntimeEvents(sessionId, runId, budget, visit)),
+            readToolProvenanceEvents: (sessionId, runId, toolCallId, budget) => run(() => runtimeEventStore.readToolProvenanceEvents(sessionId, runId, toolCallId, budget)),
             readRuntimeEventsBounded: (sessionId, runId, budget) => run(() => runtimeEventStore.readRuntimeEventsBounded(sessionId, runId, budget)),
             readImmutableRuntimeEvents: (sessionId, runId) => run(() => runtimeEventStore.readImmutableRuntimeEvents(sessionId, runId)),
             readRecoveryMessageEvents: (input) => run(() => runtimeEventStore.readRecoveryMessageEvents(input)),
@@ -524,6 +561,7 @@ async function openExecutionStoresForRead(lease, kind, extension) {
                     readSessionRuntimeSnapshot: (sessionId) => run(() => runtimeEventStore.readSessionRuntimeSnapshot(sessionId)),
                 }
                 : {}),
+            readToolProvenanceEvents: (sessionId, runId, toolCallId, budget) => run(() => runtimeEventStore.readToolProvenanceEvents(sessionId, runId, toolCallId, budget)),
             readRuntimeEventsBounded: (sessionId, runId, budget) => run(() => runtimeEventStore.readRuntimeEventsBounded(sessionId, runId, budget)),
             readImmutableRuntimeEvents: (sessionId, runId) => run(() => runtimeEventStore.readImmutableRuntimeEvents(sessionId, runId)),
             listSessionInvocations: (sessionId) => run(() => runtimeEventStore.listSessionInvocations(sessionId)),

package/node_modules/@maka/storage/dist/external-session-images.js

@@ -0,0 +1,131 @@
+/*
+ * 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.
+ */
+import { randomUUID } from 'node:crypto';
+import { constants } from 'node:fs';
+import { open } from 'node:fs/promises';
+import { basename, isAbsolute } from 'node:path';
+import { MAX_ATTACHMENT_BYTES, MAX_ATTACHMENT_COUNT, sniffAttachmentMimeType, } from '@maka/core/attachments';
+// Bound disk growth and I/O independently of the transcript's text budget.
+const MAX_IMPORT_IMAGE_BYTES = 256 * 1024 * 1024;
+/** Source paths never become published references: only verified, durable bytes do. */
+export async function prepareExternalSessionImages(sessionId, messages, sources, artifacts) {
+    const byMessage = new Map();
+    for (const source of sources) {
+        const paths = byMessage.get(source.messageId) ?? [];
+        paths.push(source.path);
+        byMessage.set(source.messageId, paths);
+    }
+    const prepared = [];
+    let totalBytes = 0;
+    try {
+        for (const message of messages) {
+            const paths = message.type === 'user' ? byMessage.get(message.id) : undefined;
+            if (message.type !== 'user' || !paths?.length) {
+                prepared.push(message);
+                continue;
+            }
+            const attachments = [...(message.attachments ?? [])];
+            const unavailable = [];
+            for (const [index, path] of paths.entries()) {
+                if (!artifacts ||
+                    index >= MAX_ATTACHMENT_COUNT ||
+                    attachments.length >= MAX_ATTACHMENT_COUNT) {
+                    unavailable.push(index + 1);
+                    continue;
+                }
+                const image = await readSourceImage(path, MAX_IMPORT_IMAGE_BYTES - totalBytes);
+                if (!image) {
+                    unavailable.push(index + 1);
+                    continue;
+                }
+                const id = `import_image_${randomUUID()}`;
+                const record = await artifacts.create({
+                    id,
+                    sessionId,
+                    // Match native uploads: the artifact owns an upload key, not a source Turn id.
+                    turnId: id,
+                    name: basename(path),
+                    kind: 'image',
+                    content: image.bytes,
+                    mimeType: image.mimeType,
+                    source: 'user_upload',
+                });
+                totalBytes += image.bytes.byteLength;
+                attachments.push({
+                    kind: 'image',
+                    name: record.name,
+                    mimeType: image.mimeType,
+                    bytes: record.sizeBytes,
+                    ref: { kind: 'session_file', sessionId, relativePath: record.id },
+                });
+            }
+            const fallback = unavailable.length > 0
+                ? `\n\n[${unavailable.length} imported image attachment(s) unavailable (source positions: ${unavailable.join(', ')}): the original file could not be recovered within attachment limits.]`
+                : '';
+            prepared.push({
+                ...message,
+                // Keep all source text, including useful metadata for unavailable originals.
+                text: message.text + fallback,
+                ...(message.displayText !== undefined
+                    ? { displayText: message.displayText + fallback }
+                    : {}),
+                ...(attachments.length ? { attachments } : {}),
+            });
+        }
+        return prepared;
+    }
+    catch (error) {
+        // No Session metadata has been committed while this preparation callback runs.
+        await artifacts?.purgeSessionArtifacts(sessionId);
+        throw error;
+    }
+}
+async function readSourceImage(path, remaining) {
+    if (!isAbsolute(path) || remaining <= 0)
+        return undefined;
+    try {
+        const handle = await open(path, constants.O_RDONLY | constants.O_NONBLOCK);
+        try {
+            const metadata = await handle.stat();
+            const limit = Math.min(MAX_ATTACHMENT_BYTES, remaining);
+            if (!metadata.isFile() || metadata.size <= 0 || metadata.size > limit)
+                return undefined;
+            // One extra byte detects growth without ever buffering an unbounded source.
+            const bytes = Buffer.alloc(metadata.size + 1);
+            let total = 0;
+            while (total < bytes.length) {
+                const read = await handle.read(bytes, total, bytes.length - total, total);
+                if (read.bytesRead === 0)
+                    break;
+                total += read.bytesRead;
+            }
+            if (total !== metadata.size)
+                return undefined;
+            const payload = bytes.subarray(0, total);
+            const mimeType = sniffAttachmentMimeType(payload);
+            return mimeType?.startsWith('image/') ? { bytes: payload, mimeType } : undefined;
+        }
+        finally {
+            await handle.close();
+        }
+    }
+    catch {
+        return undefined;
+    }
+}

package/node_modules/@maka/storage/dist/external-session-importer.js

@@ -18,6 +18,7 @@
  */
 import { decodeCanonicalMessage, isConversationTextMessage } from '@maka/core/session';
 import { sanitizeExternalSessionCwd, sanitizeExternalSessionTitle, } from '@maka/core/external-session';
+import { prepareExternalSessionImages } from './external-session-images.js';
 /**
  * Converts no formats itself. The selected adapter returns Maka StoredMessages;
  * the importer only chooses target Session settings and commits them atomically.
@@ -25,9 +26,11 @@ import { sanitizeExternalSessionCwd, sanitizeExternalSessionTitle, } from '@maka
 export class ExternalSessionImporter {
     adapters;
     sessions;
-    constructor(adapters, sessions) {
+    artifacts;
+    constructor(adapters, sessions, artifacts) {
         this.adapters = adapters;
         this.sessions = sessions;
+        this.artifacts = artifacts;
     }
     async import(request) {
         const adapter = this.adapters.require(request.adapterId);
@@ -59,6 +62,13 @@ export class ExternalSessionImporter {
         }, messages, {
             adapterId: request.adapterId,
             sourceSessionId: request.sourceSessionId,
-        });
+        }, external.sourceImages?.length
+            ? {
+                discardPreparedMessages: async (sessionId) => {
+                    await this.artifacts?.purgeSessionArtifacts(sessionId);
+                },
+                prepareMessages: (sessionId, sourceMessages) => prepareExternalSessionImages(sessionId, sourceMessages, external.sourceImages, this.artifacts),
+            }
+            : undefined);
     }
 }

package/node_modules/@maka/storage/dist/goal-authority.js

@@ -16,6 +16,7 @@
  * specific language governing permissions and limitations
  * under the License.
  */
+import { suppressPreviousBridgeWait } from './sqlite-event-wait-bridge.js';
 import { decodeGoalAuthorityRecord } from '@maka/core/goal';
 import { acquireOperationalStateDatabase, } from './operational-state-store.js';
 import { assertStorageRootLease, runWithStorageRootLease, StorageRootAuthorityError, } from './root-authority.js';
@@ -165,6 +166,7 @@ class SqliteGoalAuthority {
             if (current !== input.expectedAuthorityRevision) {
                 return { kind: 'revision_conflict', actualAuthorityRevision: current };
             }
+            suppressPreviousBridgeWait(this.#database.database, input.sessionId, input.record);
             if (input.record === null) {
                 this.#database.database
                     .prepare('DELETE FROM workflow_goal_authority WHERE session_id = ?')

package/node_modules/@maka/storage/dist/local-execution-persistence.js

@@ -24,6 +24,9 @@ import { createAgentGraphControlStore } from './agent-graph-control-store.js';
 import { createSqliteEventWaitAuthority } from './sqlite-event-wait-authority.js';
 import { createSqliteGoalAuthority } from './goal-authority.js';
 import { createSqliteInteractionStore } from './interaction-store.js';
+import { exportSessionBundleState } from './session-bundle-policy.js';
+import { createSessionSnapshotStateIdentity } from './production-session-snapshot.js';
+import { runWithStorageRootLease } from './root-authority.js';
 export const localExecutionPersistenceProvider = Object.freeze({
     async open({ canonicalPath }) {
         const closes = [];
@@ -52,7 +55,7 @@ export const localExecutionPersistenceProvider = Object.freeze({
             closes.push(() => operational.close());
             const graphControlStore = createAgentGraphControlStore(canonicalPath);
             closes.push(() => graphControlStore.close());
-            const eventWaitStore = createSqliteEventWaitAuthority(canonicalPath);
+            const eventWaitStore = createSqliteEventWaitAuthority(canonicalPath, runtime.runtimeEventStore);
             closes.push(() => eventWaitStore.close());
             const goalStore = createSqliteGoalAuthority(canonicalPath);
             closes.push(() => goalStore.close());
@@ -60,6 +63,29 @@ export const localExecutionPersistenceProvider = Object.freeze({
             closes.push(() => interactionStore.close());
             await Promise.all([sessionStore.ready(), agentRunStore.ready?.(), interactionStore.ready()]);
             return {
+                createSnapshotStatePreparer(lease) {
+                    if (lease.canonicalPath !== canonicalPath)
+                        throw new Error('Snapshot lease belongs to another backend');
+                    return {
+                        async prepareState(input) {
+                            input.cancellation.signal.throwIfAborted();
+                            // Lock order: execution fence -> Artifact writer -> context values.
+                            // The exporter holds the Artifact lock until both databases and
+                            // their payloads are private. GC/publication uses these same locks.
+                            await runWithStorageRootLease(lease, 'interactive', 'write', () => exportSessionBundleState({
+                                stateRoot: canonicalPath,
+                                configRoot: canonicalPath,
+                                allowShared: true,
+                                destinationRoot: input.destinationRoot,
+                                sessionId: input.makaSessionId,
+                                requireQuiescent: true,
+                                lease,
+                            }));
+                            input.cancellation.signal.throwIfAborted();
+                            return createSessionSnapshotStateIdentity(input.makaSessionId);
+                        },
+                    };
+                },
                 sessionStore,
                 agentRunStore,
                 runtimeEventStore: runtime.runtimeEventStore,

package/node_modules/@maka/storage/dist/operational-state-store.js

@@ -153,7 +153,7 @@ class OperationalStateDatabaseOwner {
             configureSqliteRuntimeLockWait(this.database);
             this.database.exec('PRAGMA foreign_keys = ON');
             if (options.schemaMigration !== 'require_current') {
-                configureSqliteRuntimeAutoVacuumForNewDatabase(this.database, databaseExisted);
+                configureSqliteRuntimeAutoVacuumForNewDatabase(this.database);
             }
             if (options.schemaMigration === 'require_current') {
                 requireCurrentOperationalState(this.database);