@bizagent/dsh 0.0.0-stage → 1.0.0

package/lib/ledger.js

@@ -0,0 +1,752 @@
+import { defineDomain, domainTable } from '@deepseek-ai/dsh-storage-domain';
+import { isDeepStrictEqual } from 'node:util';
+import { z } from 'zod';
+import { SharedKnowledgeProposalSchema } from './shared-knowledge.js';
+import { AgentFrameStateSchema, InboxDeliverySchema, InboxHumanNotificationSchema, HumanNotificationPreferenceSchema, InboxMessageSchema, InboxWakeOriginSchema, InboxWakePlanSchema, InboxReturnRouteSchema, FitnessReceiptSchema, LearningCheckpointSchema, LearningMaterialObservationSchema, LearningMaterialReviewSchema, LearningBatchRunSchema, LearningLaunchSchema, LearningScheduleCursorSchema, LearningSchedulePolicySchema, MemoryProposalSchema, ProjectTurnParticipationSchema, SessionBindingSchema, isUserAddress, UserAddressSchema, nowIso, stableId, } from './domain.js';
+export const BIZAGENT_DOMAIN = defineDomain({
+    name: 'bizagent_learning',
+    version: 0,
+    tables: {
+        bindings: domainTable(SessionBindingSchema),
+        proposals: domainTable(MemoryProposalSchema),
+        receipts: domainTable(FitnessReceiptSchema),
+        metadata: domainTable(z.object({
+            key: z.string().min(1),
+            value: z.string(),
+            updatedAt: z.string().min(1),
+        })),
+    },
+});
+const CHECKPOINT_PREFIX = 'learning-checkpoint:';
+const MATERIAL_OBSERVATION_PREFIX = 'learning-material-observation:';
+const MATERIAL_REVIEW_PREFIX = 'learning-material-review:';
+const LEARNING_BATCH_PREFIX = 'learning-batch:';
+const LEARNING_LAUNCH_PREFIX = 'learning-launch:';
+const LEARNING_SCHEDULE_PREFIX = 'learning-schedule:';
+const LEARNING_POLICY_PREFIX = 'learning-policy:';
+const FRAME_STATE_PREFIX = 'agent-frame-state:';
+const INBOX_MESSAGE_PREFIX = 'inbox-message:';
+const INBOX_DELIVERY_PREFIX = 'inbox-delivery:';
+const INBOX_WAKE_ORIGIN_PREFIX = 'inbox-wake-origin:';
+const INBOX_WAKE_PLAN_PREFIX = 'inbox-wake-plan:';
+const INBOX_RETURN_ROUTE_PREFIX = 'inbox-return-route:';
+const INBOX_HUMAN_NOTIFICATION_PREFIX = 'inbox-human-notification:';
+const HUMAN_NOTIFICATION_PREFERENCE_PREFIX = 'human-notification-preference:';
+const PROJECT_TURN_PREFIX = 'project-turn:';
+const SHARED_KNOWLEDGE_PROPOSAL_PREFIX = 'shared-knowledge-proposal:';
+export class LearningLedger {
+    domain;
+    receiptTail = Promise.resolve();
+    learningBatchTail = Promise.resolve();
+    materialReviewWrites = new Map();
+    frameMutationTail = new Map();
+    inboxMutationTail = Promise.resolve();
+    projectTurnTail = Promise.resolve();
+    proposalTail = Promise.resolve();
+    constructor(domain) {
+        this.domain = domain;
+    }
+    static async open(facility) {
+        return new LearningLedger(await facility.open(BIZAGENT_DOMAIN));
+    }
+    getBinding(sessionId) {
+        return this.domain.table('bindings').get(sessionId);
+    }
+    async putBinding(binding) {
+        const existing = this.getBinding(binding.sessionId);
+        if (existing !== undefined && existing.homeAddress !== binding.homeAddress) {
+            throw new Error(`session ${binding.sessionId} is already bound to ${existing.homeAddress}; cannot rebind to ${binding.homeAddress}`);
+        }
+        await this.domain.table('bindings').put(binding.sessionId, SessionBindingSchema.parse(binding));
+    }
+    /** Roll back a pre-creation reservation only after the host has verified that no Session materialized. */
+    async removeUnmaterializedBinding(binding) {
+        const current = this.getBinding(binding.sessionId);
+        if (current?.homeAddress !== binding.homeAddress || current.cwd !== binding.cwd
+            || current.boundAt !== binding.boundAt)
+            return false;
+        return this.domain.table('bindings').delete(binding.sessionId);
+    }
+    /** Forget a binding the current rules no longer make, so its Session binds afresh on its next turn. */
+    async releaseBinding(binding) {
+        const current = this.getBinding(binding.sessionId);
+        if (current?.homeAddress !== binding.homeAddress || current.cwd !== binding.cwd
+            || current.boundAt !== binding.boundAt)
+            return false;
+        return this.domain.table('bindings').delete(binding.sessionId);
+    }
+    listBindings(homeAddress) {
+        return [...this.domain.table('bindings').entries()]
+            .map(([, binding]) => binding)
+            .filter(binding => homeAddress === undefined || binding.homeAddress === homeAddress)
+            .sort((a, b) => a.boundAt.localeCompare(b.boundAt));
+    }
+    listProjectTurns(projectId) {
+        return [...this.domain.table('metadata').entries()]
+            .filter(([key]) => key.startsWith(PROJECT_TURN_PREFIX))
+            .map(([, record]) => ProjectTurnParticipationSchema.parse(JSON.parse(record.value)))
+            .filter(item => projectId === undefined || item.projectId === projectId)
+            .sort((a, b) => a.recordedAt.localeCompare(b.recordedAt)
+            || a.sessionId.localeCompare(b.sessionId) || a.turn - b.turn);
+    }
+    async putProjectTurn(input) {
+        const task = this.projectTurnTail.catch(() => undefined).then(async () => {
+            const key = `${PROJECT_TURN_PREFIX}${stableId('project-turn', JSON.stringify([
+                input.projectId, input.sessionId, input.turn,
+            ]))}`;
+            const previous = this.domain.table('metadata').get(key);
+            if (previous !== undefined) {
+                const existing = ProjectTurnParticipationSchema.parse(JSON.parse(previous.value));
+                if (existing.projectId !== input.projectId || existing.sessionId !== input.sessionId
+                    || existing.turn !== input.turn || existing.homeAddress !== input.homeAddress) {
+                    throw new Error('Project turn participation conflicts with its prior binding');
+                }
+                return existing;
+            }
+            const binding = this.getBinding(input.sessionId);
+            if (binding?.homeAddress !== input.homeAddress) {
+                throw new Error('Project turn requires a durable matching Home Session binding');
+            }
+            const participation = ProjectTurnParticipationSchema.parse({
+                schemaVersion: 1, ...input, recordedAt: nowIso(),
+            });
+            await this.domain.table('metadata').put(key, {
+                key, value: JSON.stringify(participation), updatedAt: participation.recordedAt,
+            });
+            return participation;
+        });
+        this.projectTurnTail = task;
+        return task;
+    }
+    getFrameState(sessionId) {
+        const record = this.domain.table('metadata').get(`${FRAME_STATE_PREFIX}${sessionId}`);
+        return record === undefined
+            ? undefined
+            : AgentFrameStateSchema.parse(JSON.parse(record.value));
+    }
+    async updateFrameState(sessionId, update) {
+        const previous = this.frameMutationTail.get(sessionId);
+        const task = (previous?.catch(() => undefined) ?? Promise.resolve()).then(async () => {
+            const state = AgentFrameStateSchema.parse(update(this.getFrameState(sessionId)));
+            if (state.sessionId !== sessionId)
+                throw new Error('Frame state Session mismatch');
+            const key = `${FRAME_STATE_PREFIX}${sessionId}`;
+            await this.domain.table('metadata').put(key, {
+                key,
+                value: JSON.stringify(state),
+                updatedAt: state.updatedAt,
+            });
+            return state;
+        });
+        this.frameMutationTail.set(sessionId, task);
+        try {
+            return await task;
+        }
+        finally {
+            if (this.frameMutationTail.get(sessionId) === task)
+                this.frameMutationTail.delete(sessionId);
+        }
+    }
+    async withInboxWrite(update) {
+        const task = this.inboxMutationTail.catch(() => undefined).then(update);
+        this.inboxMutationTail = task;
+        return task;
+    }
+    getInboxMessage(id) {
+        const record = this.domain.table('metadata').get(`${INBOX_MESSAGE_PREFIX}${id}`);
+        return record === undefined ? undefined
+            : InboxMessageSchema.parse(JSON.parse(record.value));
+    }
+    listInboxMessages() {
+        return [...this.domain.table('metadata').entries()]
+            .filter(([key]) => key.startsWith(INBOX_MESSAGE_PREFIX))
+            .map(([, record]) => InboxMessageSchema.parse(JSON.parse(record.value)))
+            .sort((a, b) => b.sentAt.localeCompare(a.sentAt) || b.id.localeCompare(a.id));
+    }
+    async putInboxMessage(message) {
+        const parsed = InboxMessageSchema.parse(message);
+        const key = `${INBOX_MESSAGE_PREFIX}${parsed.id}`;
+        if (this.getInboxMessage(parsed.id) !== undefined)
+            throw new Error(`Inbox message already exists: ${parsed.id}`);
+        await this.domain.table('metadata').put(key, {
+            key, value: JSON.stringify(parsed), updatedAt: parsed.sentAt,
+        });
+    }
+    getInboxDelivery(messageId, recipient) {
+        const record = this.domain.table('metadata').get(`${INBOX_DELIVERY_PREFIX}${messageId}:${recipient}`);
+        return record === undefined ? undefined
+            : InboxDeliverySchema.parse(JSON.parse(record.value));
+    }
+    async putInboxDelivery(delivery) {
+        const parsed = InboxDeliverySchema.parse(delivery);
+        const key = `${INBOX_DELIVERY_PREFIX}${parsed.messageId}:${parsed.recipient}`;
+        await this.domain.table('metadata').put(key, {
+            key, value: JSON.stringify(parsed), updatedAt: parsed.updatedAt,
+        });
+    }
+    getInboxHumanNotification(messageId, recipient) {
+        const record = this.domain.table('metadata').get(`${INBOX_HUMAN_NOTIFICATION_PREFIX}${messageId}:${recipient}`);
+        return record === undefined ? undefined
+            : InboxHumanNotificationSchema.parse(JSON.parse(record.value));
+    }
+    getHumanNotificationPreference(recipient) {
+        const record = this.domain.table('metadata').get(`${HUMAN_NOTIFICATION_PREFERENCE_PREFIX}${recipient}`);
+        return record === undefined ? undefined
+            : HumanNotificationPreferenceSchema.parse(JSON.parse(record.value));
+    }
+    async setHumanNotificationPreference(recipient, enabled, expectedRevision) {
+        const address = UserAddressSchema.parse(recipient);
+        if (!Number.isSafeInteger(expectedRevision) || expectedRevision < 0) {
+            throw new Error('human notification preference revision is invalid');
+        }
+        return this.withInboxWrite(async () => {
+            const prior = this.getHumanNotificationPreference(address);
+            if ((prior?.revision ?? 0) !== expectedRevision) {
+                throw new Error('human notification preference changed before update');
+            }
+            const updatedAt = nowIso();
+            const preference = HumanNotificationPreferenceSchema.parse({ schemaVersion: 1,
+                recipient: address, enabled, revision: expectedRevision + 1, updatedAt });
+            const key = `${HUMAN_NOTIFICATION_PREFERENCE_PREFIX}${address}`;
+            await this.domain.table('metadata').put(key, {
+                key, value: JSON.stringify(preference), updatedAt,
+            });
+            return preference;
+        });
+    }
+    /** The external provider was never called; this terminal record survives later opt-in. */
+    async suppressInboxHumanNotification(messageId, recipient, reason) {
+        const address = UserAddressSchema.parse(recipient);
+        if (!reason.trim() || reason.length > 500)
+            throw new Error('human notification suppression needs a reason');
+        return this.withInboxWrite(async () => {
+            const prior = this.getInboxHumanNotification(messageId, address);
+            if (prior) {
+                if (prior.status !== 'suppressed' || prior.reason !== reason) {
+                    throw new Error('human notification already has a channel outcome');
+                }
+                return prior;
+            }
+            const message = this.getInboxMessage(messageId);
+            const delivery = this.getInboxDelivery(messageId, address);
+            if (!message || ![...message.to, ...message.cc].includes(address)
+                || delivery?.status !== 'delivered' || delivery.handledAt !== undefined) {
+                throw new Error('human notification source is not pending in the recipient inbox');
+            }
+            return this.putSuppressedHumanNotification(messageId, address, reason);
+        });
+    }
+    async putSuppressedHumanNotification(messageId, recipient, reason) {
+        const suppressedAt = nowIso();
+        const notification = InboxHumanNotificationSchema.parse({ schemaVersion: 1,
+            id: stableId('inbox-human-suppressed', `${messageId}:${recipient}`),
+            messageId, recipient, attempt: 0, status: 'suppressed',
+            suppressedAt, resolvedAt: suppressedAt, reason,
+        });
+        const key = `${INBOX_HUMAN_NOTIFICATION_PREFIX}${messageId}:${recipient}`;
+        await this.domain.table('metadata').put(key, {
+            key, value: JSON.stringify(notification), updatedAt: suppressedAt,
+        });
+        return notification;
+    }
+    /** Persist an opt-out while holding the same lock as preference updates and channel reservations. */
+    async suppressInboxHumanNotificationIfOptedOut(messageId, recipient) {
+        return this.withInboxWrite(async () => {
+            if (this.getHumanNotificationPreference(recipient)?.enabled !== false)
+                return undefined;
+            const existing = this.getInboxHumanNotification(messageId, recipient);
+            if (existing)
+                return existing.status === 'suppressed' ? existing : undefined;
+            const message = this.getInboxMessage(messageId);
+            const delivery = this.getInboxDelivery(messageId, recipient);
+            if (!message || ![...message.to, ...message.cc].includes(recipient)
+                || delivery?.status !== 'delivered' || delivery.handledAt !== undefined) {
+                throw new Error('human notification source is not pending in the recipient inbox');
+            }
+            return this.putSuppressedHumanNotification(messageId, recipient, 'recipient-opted-out');
+        });
+    }
+    /** Reserve before calling the channel; a crash leaves unknown and never causes an automatic resend. */
+    async reserveInboxHumanNotification(messageId, recipient) {
+        if (!isUserAddress(recipient))
+            throw new Error('human notification requires a user recipient');
+        return this.withInboxWrite(async () => {
+            const existing = this.getInboxHumanNotification(messageId, recipient);
+            if (existing !== undefined)
+                return { notification: existing, reserved: false };
+            const message = this.getInboxMessage(messageId);
+            const delivery = this.getInboxDelivery(messageId, recipient);
+            if (message === undefined || ![...message.to, ...message.cc].includes(recipient)
+                || delivery?.status !== 'delivered' || delivery.handledAt !== undefined) {
+                throw new Error('human notification source is not pending in the recipient inbox');
+            }
+            if (this.getHumanNotificationPreference(recipient)?.enabled === false) {
+                return { notification: await this.putSuppressedHumanNotification(messageId, recipient, 'recipient-opted-out'), reserved: false };
+            }
+            const attemptedAt = nowIso();
+            const notification = InboxHumanNotificationSchema.parse({
+                schemaVersion: 1, id: stableId('inbox-human-notice', `${messageId}:${recipient}`),
+                messageId, recipient, status: 'unknown', attemptedAt,
+            });
+            const key = `${INBOX_HUMAN_NOTIFICATION_PREFIX}${messageId}:${recipient}`;
+            await this.domain.table('metadata').put(key, {
+                key, value: JSON.stringify(notification), updatedAt: attemptedAt,
+            });
+            return { notification, reserved: true };
+        });
+    }
+    async settleInboxHumanNotification(messageId, recipient, outcome) {
+        return this.withInboxWrite(async () => {
+            const prior = this.getInboxHumanNotification(messageId, recipient);
+            if (prior === undefined)
+                throw new Error('human notification was not reserved');
+            if (prior.status !== 'unknown') {
+                if (prior.status !== outcome.status
+                    || (outcome.status === 'sent' && prior.providerReceipt !== outcome.providerReceipt)
+                    || (outcome.status === 'rejected' && prior.reason !== outcome.reason)) {
+                    throw new Error('human notification is already settled differently');
+                }
+                return prior;
+            }
+            const resolvedAt = nowIso();
+            const notification = InboxHumanNotificationSchema.parse({
+                ...prior, ...outcome, resolvedAt,
+            });
+            const key = `${INBOX_HUMAN_NOTIFICATION_PREFIX}${messageId}:${recipient}`;
+            await this.domain.table('metadata').put(key, {
+                key, value: JSON.stringify(notification), updatedAt: resolvedAt,
+            });
+            return notification;
+        });
+    }
+    /** A definite rejection permits one explicit new attempt; unknown and sent never do. */
+    async retryRejectedInboxHumanNotification(messageId, recipient) {
+        return this.withInboxWrite(async () => {
+            const prior = this.getInboxHumanNotification(messageId, recipient);
+            const delivery = this.getInboxDelivery(messageId, recipient);
+            if (prior?.status !== 'rejected' || prior.resolvedAt === undefined || prior.reason === undefined
+                || delivery?.status !== 'delivered' || delivery.handledAt !== undefined) {
+                throw new Error('human notification is not a pending, definitely rejected recipient');
+            }
+            if (this.getHumanNotificationPreference(recipient)?.enabled === false) {
+                throw new Error('human notification recipient has opted out');
+            }
+            const attemptedAt = nowIso();
+            const notification = InboxHumanNotificationSchema.parse({
+                schemaVersion: 1, id: stableId('inbox-human-notice', `${messageId}:${recipient}:${prior.attempt + 1}`),
+                messageId, recipient, attempt: prior.attempt + 1,
+                priorRejections: [...prior.priorRejections, {
+                        id: prior.id, attemptedAt: prior.attemptedAt,
+                        resolvedAt: prior.resolvedAt, reason: prior.reason,
+                    }],
+                status: 'unknown', attemptedAt,
+            });
+            const key = `${INBOX_HUMAN_NOTIFICATION_PREFIX}${messageId}:${recipient}`;
+            await this.domain.table('metadata').put(key, {
+                key, value: JSON.stringify(notification), updatedAt: attemptedAt,
+            });
+            return notification;
+        });
+    }
+    getInboxWakeOrigin(sessionId) {
+        const record = this.domain.table('metadata').get(`${INBOX_WAKE_ORIGIN_PREFIX}${sessionId}`);
+        return record === undefined ? undefined
+            : InboxWakeOriginSchema.parse(JSON.parse(record.value));
+    }
+    async putInboxWakeOrigin(origin) {
+        const parsed = InboxWakeOriginSchema.parse(origin);
+        return this.withInboxWrite(async () => {
+            const existing = this.getInboxWakeOrigin(parsed.sessionId);
+            if (existing !== undefined) {
+                if (JSON.stringify(existing) !== JSON.stringify(parsed)) {
+                    throw new Error('Inbox wake Session already has another origin');
+                }
+                return existing;
+            }
+            const key = `${INBOX_WAKE_ORIGIN_PREFIX}${parsed.sessionId}`;
+            await this.domain.table('metadata').put(key, {
+                key, value: JSON.stringify(parsed), updatedAt: parsed.createdAt,
+            });
+            return parsed;
+        });
+    }
+    getInboxWakePlan(id) {
+        const record = this.domain.table('metadata').get(`${INBOX_WAKE_PLAN_PREFIX}${id}`);
+        return record === undefined ? undefined
+            : InboxWakePlanSchema.parse(JSON.parse(record.value));
+    }
+    listInboxWakePlans() {
+        return [...this.domain.table('metadata').entries()]
+            .filter(([key]) => key.startsWith(INBOX_WAKE_PLAN_PREFIX))
+            .map(([, record]) => InboxWakePlanSchema.parse(JSON.parse(record.value)))
+            .sort((a, b) => a.createdAt.localeCompare(b.createdAt) || a.id.localeCompare(b.id));
+    }
+    /** Caller holds withInboxWrite so plan selection and reservation share one local writer. */
+    async putInboxWakePlan(plan) {
+        const parsed = InboxWakePlanSchema.parse(plan);
+        const existing = this.getInboxWakePlan(parsed.id);
+        if (existing !== undefined) {
+            if (JSON.stringify(existing) !== JSON.stringify(parsed))
+                throw new Error('Inbox wake plan ID conflicts');
+            return existing;
+        }
+        const key = `${INBOX_WAKE_PLAN_PREFIX}${parsed.id}`;
+        await this.domain.table('metadata').put(key, {
+            key, value: JSON.stringify(parsed), updatedAt: parsed.createdAt,
+        });
+        return parsed;
+    }
+    async markInboxWakeDispatched(id, dispatchedAt, retiredReason) {
+        return this.withInboxWrite(async () => {
+            const plan = this.getInboxWakePlan(id);
+            if (plan === undefined)
+                throw new Error(`Inbox wake plan not found: ${id}`);
+            if (plan.dispatchedAt !== undefined)
+                return plan;
+            const updated = InboxWakePlanSchema.parse({ ...plan, dispatchedAt,
+                ...(retiredReason !== undefined ? { retiredReason: retiredReason.slice(0, 500) } : {}) });
+            const key = `${INBOX_WAKE_PLAN_PREFIX}${id}`;
+            await this.domain.table('metadata').put(key, {
+                key, value: JSON.stringify(updated), updatedAt: dispatchedAt,
+            });
+            return updated;
+        });
+    }
+    getInboxReturnRoute(messageId, recipient) {
+        const record = this.domain.table('metadata').get(`${INBOX_RETURN_ROUTE_PREFIX}${messageId}:${recipient}`);
+        return record === undefined ? undefined
+            : InboxReturnRouteSchema.parse(JSON.parse(record.value));
+    }
+    async putInboxReturnRoute(route) {
+        const parsed = InboxReturnRouteSchema.parse(route);
+        return this.withInboxWrite(async () => {
+            const existing = this.getInboxReturnRoute(parsed.messageId, parsed.recipient);
+            if (existing !== undefined) {
+                if (existing.sessionId !== parsed.sessionId)
+                    throw new Error('Inbox return route Session changed');
+                if (existing.status === 'fallback' || existing.status === parsed.status)
+                    return existing;
+            }
+            const key = `${INBOX_RETURN_ROUTE_PREFIX}${parsed.messageId}:${parsed.recipient}`;
+            await this.domain.table('metadata').put(key, {
+                key, value: JSON.stringify(parsed), updatedAt: parsed.updatedAt,
+            });
+            return parsed;
+        });
+    }
+    getMaterialObservation(id) {
+        const record = this.domain.table('metadata').get(`${MATERIAL_OBSERVATION_PREFIX}${id}`);
+        return record === undefined
+            ? undefined
+            : LearningMaterialObservationSchema.parse(JSON.parse(record.value));
+    }
+    async putMaterialObservation(observation) {
+        const parsed = LearningMaterialObservationSchema.parse(observation);
+        const existing = this.getMaterialObservation(parsed.id);
+        if (existing !== undefined) {
+            if (existing.homeAddress !== parsed.homeAddress || existing.sessionId !== parsed.sessionId
+                || existing.fingerprint !== parsed.fingerprint || existing.sourceKind !== parsed.sourceKind
+                || existing.worklogRevisionId !== parsed.worklogRevisionId
+                || existing.worklogRevision !== parsed.worklogRevision) {
+                throw new Error(`learning material observation ${parsed.id} conflicts with an existing source`);
+            }
+            return existing;
+        }
+        const key = `${MATERIAL_OBSERVATION_PREFIX}${parsed.id}`;
+        await this.domain.table('metadata').put(key, {
+            key,
+            value: JSON.stringify(parsed),
+            updatedAt: parsed.observedAt,
+        });
+        return parsed;
+    }
+    getMaterialReview(materialId) {
+        const record = this.domain.table('metadata').get(`${MATERIAL_REVIEW_PREFIX}${materialId}`);
+        return record === undefined
+            ? undefined
+            : LearningMaterialReviewSchema.parse(JSON.parse(record.value));
+    }
+    async putMaterialReview(review) {
+        const parsed = LearningMaterialReviewSchema.parse(review);
+        const pending = this.materialReviewWrites.get(parsed.materialId);
+        if (pending !== undefined)
+            return pending;
+        const write = (async () => {
+            const existing = this.getMaterialReview(parsed.materialId);
+            if (existing !== undefined)
+                return existing;
+            const key = `${MATERIAL_REVIEW_PREFIX}${parsed.materialId}`;
+            await this.domain.table('metadata').put(key, {
+                key,
+                value: JSON.stringify(parsed),
+                updatedAt: parsed.reviewedAt,
+            });
+            return parsed;
+        })();
+        this.materialReviewWrites.set(parsed.materialId, write);
+        try {
+            return await write;
+        }
+        finally {
+            this.materialReviewWrites.delete(parsed.materialId);
+        }
+    }
+    async withLearningBatchWrite(update) {
+        const task = this.learningBatchTail.catch(() => undefined).then(update);
+        this.learningBatchTail = task.then(() => undefined, () => undefined);
+        return task;
+    }
+    getLearningBatch(id) {
+        const record = this.domain.table('metadata').get(`${LEARNING_BATCH_PREFIX}${id}`);
+        return record === undefined ? undefined
+            : LearningBatchRunSchema.parse(JSON.parse(record.value));
+    }
+    listLearningBatches(homeAddress) {
+        return [...this.domain.table('metadata').entries()]
+            .filter(([key]) => key.startsWith(LEARNING_BATCH_PREFIX))
+            .map(([, record]) => LearningBatchRunSchema.parse(JSON.parse(record.value)))
+            .filter(run => run.homeAddress === homeAddress)
+            .sort((a, b) => b.createdAt.localeCompare(a.createdAt) || b.id.localeCompare(a.id));
+    }
+    async putLearningBatch(run) {
+        const parsed = LearningBatchRunSchema.parse(run);
+        const previous = this.getLearningBatch(parsed.id);
+        if (previous !== undefined) {
+            if (previous.homeAddress !== parsed.homeAddress || previous.reviewerSessionId !== parsed.reviewerSessionId
+                || JSON.stringify(previous.materialIds) !== JSON.stringify(parsed.materialIds)
+                || previous.status !== 'open' || parsed.status === 'open') {
+                throw new Error(`learning batch ${parsed.id} cannot be replaced`);
+            }
+        }
+        const key = `${LEARNING_BATCH_PREFIX}${parsed.id}`;
+        await this.domain.table('metadata').put(key, {
+            key, value: JSON.stringify(parsed), updatedAt: parsed.updatedAt,
+        });
+        return parsed;
+    }
+    getLearningLaunch(id) {
+        const record = this.domain.table('metadata').get(`${LEARNING_LAUNCH_PREFIX}${id}`);
+        return record === undefined ? undefined
+            : LearningLaunchSchema.parse(JSON.parse(record.value));
+    }
+    listLearningLaunches(homeAddress) {
+        return [...this.domain.table('metadata').entries()]
+            .filter(([key]) => key.startsWith(LEARNING_LAUNCH_PREFIX))
+            .map(([, record]) => LearningLaunchSchema.parse(JSON.parse(record.value)))
+            .filter(item => homeAddress === undefined || item.homeAddress === homeAddress)
+            .sort((a, b) => b.createdAt.localeCompare(a.createdAt) || b.id.localeCompare(a.id));
+    }
+    async putLearningLaunch(launch) {
+        const parsed = LearningLaunchSchema.parse(launch);
+        const prior = this.getLearningLaunch(parsed.id);
+        if (prior !== undefined && (prior.homeAddress !== parsed.homeAddress
+            || prior.requestedBySessionId !== parsed.requestedBySessionId
+            || prior.workerSessionId !== parsed.workerSessionId
+            || prior.workspace !== parsed.workspace
+            || prior.promptMessageId !== parsed.promptMessageId
+            || prior.provider !== parsed.provider || prior.model !== parsed.model
+            || prior.maxTokens !== parsed.maxTokens || prior.trigger !== parsed.trigger
+            || prior.scheduledFor !== parsed.scheduledFor)) {
+            throw new Error(`learning launch ${parsed.id} immutable fields changed`);
+        }
+        if (prior !== undefined && !{
+            reserved: ['reserved', 'active', 'needs_review', 'completed'],
+            active: ['active', 'completed', 'needs_review'],
+            completed: ['completed'],
+            needs_review: ['needs_review', 'abandoned', 'completed'],
+            abandoned: ['abandoned'],
+        }[prior.status].includes(parsed.status)) {
+            throw new Error(`learning launch ${parsed.id} cannot move from ${prior.status} to ${parsed.status}`);
+        }
+        const key = `${LEARNING_LAUNCH_PREFIX}${parsed.id}`;
+        await this.domain.table('metadata').put(key, {
+            key, value: JSON.stringify(parsed), updatedAt: parsed.updatedAt,
+        });
+        return parsed;
+    }
+    getLearningScheduleCursor(homeAddress) {
+        const record = this.domain.table('metadata').get(`${LEARNING_SCHEDULE_PREFIX}${homeAddress}`);
+        return record === undefined ? undefined
+            : LearningScheduleCursorSchema.parse(JSON.parse(record.value));
+    }
+    async putLearningScheduleCursor(cursor) {
+        const parsed = LearningScheduleCursorSchema.parse(cursor);
+        const key = `${LEARNING_SCHEDULE_PREFIX}${parsed.homeAddress}`;
+        const previous = this.getLearningScheduleCursor(parsed.homeAddress);
+        if (previous?.scheduleFingerprint === parsed.scheduleFingerprint
+            && (parsed.nextDueAt < previous.nextDueAt
+                || (parsed.lastDueAt !== undefined && previous.lastDueAt !== undefined
+                    && parsed.lastDueAt < previous.lastDueAt))) {
+            throw new Error('learning schedule cursor cannot move backward');
+        }
+        await this.domain.table('metadata').put(key, {
+            key, value: JSON.stringify(parsed), updatedAt: parsed.updatedAt,
+        });
+        return parsed;
+    }
+    getLearningSchedulePolicy(homeAddress) {
+        const record = this.domain.table('metadata').get(`${LEARNING_POLICY_PREFIX}${homeAddress}`);
+        return record === undefined ? undefined
+            : LearningSchedulePolicySchema.parse(JSON.parse(record.value));
+    }
+    /** Caller holds the learning batch write lock and checks the prior revision. */
+    async putLearningSchedulePolicy(policy) {
+        const parsed = LearningSchedulePolicySchema.parse(policy);
+        const prior = this.getLearningSchedulePolicy(parsed.homeAddress);
+        if (parsed.revision !== (prior?.revision ?? 0) + 1) {
+            throw new Error('learning schedule policy revision conflict');
+        }
+        const key = `${LEARNING_POLICY_PREFIX}${parsed.homeAddress}`;
+        await this.domain.table('metadata').put(key, {
+            key, value: JSON.stringify(parsed), updatedAt: parsed.updatedAt,
+        });
+        return parsed;
+    }
+    getProposal(id) {
+        const value = this.domain.table('proposals').get(id);
+        return value === undefined ? undefined : MemoryProposalSchema.parse(value);
+    }
+    async putProposal(proposal) {
+        const parsed = MemoryProposalSchema.parse(proposal);
+        const task = this.proposalTail.catch(() => undefined).then(async () => {
+            const prior = this.getProposal(parsed.id);
+            if (prior) {
+                const identity = (item) => ({ id: item.id, fromAddress: item.fromAddress,
+                    toAddress: item.toAddress, proposedKind: item.proposedKind, description: item.description,
+                    body: item.body, tags: item.tags, sourceRefs: item.sourceRefs,
+                    baseAsset: item.baseAsset, createdAt: item.createdAt });
+                if (!isDeepStrictEqual(identity(prior), identity(parsed))) {
+                    throw new Error(`memory proposal identity changed: ${parsed.id}`);
+                }
+                if (prior.status !== 'pending' && !isDeepStrictEqual(prior, parsed)) {
+                    throw new Error(`memory proposal decision is immutable: ${parsed.id}`);
+                }
+                if (prior.humanReview && !isDeepStrictEqual(prior.humanReview, parsed.humanReview)) {
+                    throw new Error(`memory proposal human review is immutable: ${parsed.id}`);
+                }
+                if (prior.status === 'pending' && parsed.status === 'pending'
+                    && !isDeepStrictEqual(prior, parsed)) {
+                    const { humanReview: _before, ...before } = prior;
+                    const { humanReview: _after, ...after } = parsed;
+                    if (prior.humanReview || !parsed.humanReview || !isDeepStrictEqual(before, after)) {
+                        throw new Error(`pending memory proposal changed: ${parsed.id}`);
+                    }
+                }
+                if (isDeepStrictEqual(prior, parsed))
+                    return;
+            }
+            await this.domain.table('proposals').put(parsed.id, parsed);
+        });
+        this.proposalTail = task;
+        await task;
+    }
+    listProposals(options = {}) {
+        return [...this.domain.table('proposals').entries()]
+            .map(([, proposal]) => MemoryProposalSchema.parse(proposal))
+            .filter(proposal => options.fromAddress === undefined || proposal.fromAddress === options.fromAddress)
+            .filter(proposal => options.toAddress === undefined || proposal.toAddress === options.toAddress)
+            .filter(proposal => options.status === undefined || proposal.status === options.status)
+            .sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+    }
+    getSharedKnowledgeProposal(id) {
+        const value = this.domain.table('metadata').get(`${SHARED_KNOWLEDGE_PROPOSAL_PREFIX}${id}`);
+        return value === undefined ? undefined : SharedKnowledgeProposalSchema.parse(JSON.parse(value.value));
+    }
+    listSharedKnowledgeProposals(status) {
+        return [...this.domain.table('metadata').entries()]
+            .filter(([key]) => key.startsWith(SHARED_KNOWLEDGE_PROPOSAL_PREFIX))
+            .map(([, entry]) => SharedKnowledgeProposalSchema.parse(JSON.parse(entry.value)))
+            .filter(proposal => status === undefined || proposal.status === status)
+            .sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+    }
+    async putSharedKnowledgeProposal(input) {
+        const proposal = SharedKnowledgeProposalSchema.parse(input);
+        const task = this.proposalTail.catch(() => undefined).then(async () => {
+            const prior = this.getSharedKnowledgeProposal(proposal.id);
+            if (prior) {
+                const identity = (item) => ({ id: item.id, fromAddress: item.fromAddress,
+                    target: item.target, description: item.description, body: item.body,
+                    sourceRefs: item.sourceRefs, createdAt: item.createdAt });
+                if (!isDeepStrictEqual(identity(prior), identity(proposal))) {
+                    throw new Error(`shared Knowledge proposal identity changed: ${proposal.id}`);
+                }
+                if (prior.status !== 'pending' && !isDeepStrictEqual(prior, proposal)) {
+                    throw new Error(`shared Knowledge decision is immutable: ${proposal.id}`);
+                }
+                if (prior.humanReview && !isDeepStrictEqual(prior.humanReview, proposal.humanReview)) {
+                    throw new Error(`shared Knowledge human review is immutable: ${proposal.id}`);
+                }
+                if (prior.status === 'pending' && proposal.status === 'pending'
+                    && (!proposal.humanReview || prior.humanReview)) {
+                    if (!isDeepStrictEqual(prior, proposal)) {
+                        throw new Error(`pending shared Knowledge proposal changed: ${proposal.id}`);
+                    }
+                }
+                if (isDeepStrictEqual(prior, proposal))
+                    return proposal;
+            }
+            const key = `${SHARED_KNOWLEDGE_PROPOSAL_PREFIX}${proposal.id}`;
+            await this.domain.table('metadata').put(key, {
+                key, value: JSON.stringify(proposal), updatedAt: nowIso(),
+            });
+            return proposal;
+        });
+        this.proposalTail = task;
+        return await task;
+    }
+    async putReceipt(receipt) {
+        const parsed = FitnessReceiptSchema.parse(receipt);
+        const task = this.receiptTail.catch(() => undefined).then(async () => {
+            const existing = this.domain.table('receipts').get(parsed.id);
+            if (existing !== undefined) {
+                const { createdAt: _previousTime, ...previous } = existing;
+                const { createdAt: _nextTime, ...next } = parsed;
+                if (JSON.stringify(previous) !== JSON.stringify(next)) {
+                    throw new Error(`fitness receipt conflicts with its prior value: ${parsed.id}`);
+                }
+                return false;
+            }
+            await this.domain.table('receipts').put(parsed.id, parsed);
+            return true;
+        });
+        this.receiptTail = task;
+        return task;
+    }
+    listReceipts(assetId) {
+        return [...this.domain.table('receipts').entries()]
+            .map(([, receipt]) => receipt)
+            .filter(receipt => assetId === undefined || receipt.assetId === assetId)
+            .sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+    }
+    getCheckpoint(id) {
+        const record = this.domain.table('metadata').get(checkpointKey(id));
+        if (record === undefined)
+            return undefined;
+        return LearningCheckpointSchema.parse(JSON.parse(record.value));
+    }
+    async putCheckpoint(checkpoint) {
+        const parsed = LearningCheckpointSchema.parse(checkpoint);
+        const key = checkpointKey(parsed.id);
+        await this.domain.table('metadata').put(key, {
+            key,
+            value: JSON.stringify(parsed),
+            updatedAt: parsed.settledAt ?? parsed.createdAt,
+        });
+    }
+    listCheckpoints(options = {}) {
+        return [...this.domain.table('metadata').entries()]
+            .filter(([key]) => key.startsWith(CHECKPOINT_PREFIX))
+            .map(([, record]) => LearningCheckpointSchema.parse(JSON.parse(record.value)))
+            .filter(item => options.sessionId === undefined || item.sessionId === options.sessionId)
+            .filter(item => options.homeAddress === undefined || item.homeAddress === options.homeAddress)
+            .filter(item => options.status === undefined || item.status === options.status)
+            .sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+    }
+    async close() {
+        await this.domain.close();
+    }
+}
+function checkpointKey(id) {
+    return `${CHECKPOINT_PREFIX}${id}`;
+}
+//# sourceMappingURL=ledger.js.map