@abot-ai/runtime 1.4.0 → 1.5.0

package/dist/src/runtime/local-host/reconnectable-connection.js

@@ -0,0 +1,96 @@
+import { connectToRuntimeOwner } from "./startup-connection.js";
+/** A fresh explicit attachment retains the original owner's credentials and lease. */
+export function createReconnectableRuntimeConnection(initialPeer, endpoint, ownership, closeOwner, isOwnerIdle = () => false) {
+    let peer = initialPeer;
+    let disconnected = false;
+    let shutdown;
+    let connecting;
+    let handler;
+    const listeners = new Set();
+    const closeListeners = new Set();
+    function bind(current) {
+        if (handler)
+            current.setHandler(handler);
+        current.subscribe((event) => {
+            for (const listener of listeners)
+                safelyNotify(() => listener(event));
+        });
+        current.onClose(() => {
+            if (current !== peer)
+                return;
+            disconnected = true;
+            for (const listener of closeListeners)
+                safelyNotify(listener);
+        });
+    }
+    async function attachToOriginalOwner() {
+        const attached = await connectToRuntimeOwner(endpoint, Date.now() + 10_000);
+        if (shutdown) {
+            attached.close();
+            throw new Error("local_runtime_stopped");
+        }
+        peer = attached;
+        disconnected = false;
+        bind(attached);
+        return true;
+    }
+    function close() {
+        if (shutdown)
+            return shutdown;
+        // Owner shutdown must synchronously close intake before its first await.
+        shutdown = closeOwner ? closeOwner() : Promise.resolve(peer.close());
+        return shutdown;
+    }
+    bind(peer);
+    return Object.freeze({
+        ownership,
+        isOwnerIdle: () => !shutdown && isOwnerIdle(),
+        closeIfIdle: () => {
+            if (ownership !== "owner")
+                return Promise.resolve(false);
+            if (shutdown)
+                return shutdown.then(() => true);
+            if (!isOwnerIdle())
+                return Promise.resolve(false);
+            return close().then(() => true);
+        },
+        call: (method, args) => peer.call(method, args),
+        subscribe: (listener) => {
+            listeners.add(listener);
+            return () => {
+                listeners.delete(listener);
+            };
+        },
+        setClientHandler: (nextHandler) => {
+            handler = nextHandler;
+            peer.setHandler(nextHandler);
+        },
+        onClose: (listener) => {
+            closeListeners.add(listener);
+            if (disconnected)
+                safelyNotify(listener);
+            return () => {
+                closeListeners.delete(listener);
+            };
+        },
+        reconnect: () => {
+            if (shutdown)
+                return Promise.reject(new Error("local_runtime_stopped"));
+            if (!disconnected)
+                return Promise.resolve(false);
+            connecting ??= attachToOriginalOwner().finally(() => {
+                connecting = undefined;
+            });
+            return connecting;
+        },
+        close,
+    });
+}
+function safelyNotify(listener) {
+    try {
+        listener();
+    }
+    catch {
+        // An observer cannot interfere with another client projection.
+    }
+}

package/dist/src/runtime/local-host/request-approval-contracts.d.ts

@@ -0,0 +1,31 @@
+import type { SchedulerRun } from "../scheduler/contracts.js";
+import type { ToolApprovalRequest } from "../ports.js";
+/** Safe approval projection. Durable waits contain identity, never executable data. */
+export type LocalPendingToolApproval = Readonly<{
+    sessionId: string;
+    run?: SchedulerRun;
+    request: ToolApprovalRequest;
+    wait?: Readonly<{
+        generation: string;
+        waitId: string;
+        revision: number;
+    }>;
+}>;
+export type LocalToolApprovalDecisionInput = Readonly<{
+    sessionId: string;
+    requestId: string;
+    approvalId: string;
+    approved: boolean;
+    reason?: string;
+    generation?: string;
+    waitId?: string;
+    revision?: number;
+    commandId?: string;
+}>;
+export type LocalToolApprovalDecisionResult = Readonly<{
+    accepted: true;
+    duplicate?: boolean;
+}> | Readonly<{
+    accepted: false;
+    reason: "approval_not_pending" | "approval_identity_mismatch" | "approval_request_not_attached" | "approval_resume_unavailable" | "approval_conflict" | "invalid_approval_decision";
+}>;

package/dist/src/runtime/local-host/request-approval-contracts.js

@@ -0,0 +1 @@
+export {};

package/dist/src/runtime/local-host/saved-approvals.d.ts

@@ -0,0 +1,30 @@
+import type { RuntimeApplication } from "../composition.js";
+import type { LocalRuntimePeer } from "./contracts.js";
+import type { LocalRequestControls } from "./app-request-control.js";
+import type { LocalRuntimeOwnerActivity } from "./owner-activity.js";
+import type { LocalPendingToolApproval, LocalToolApprovalDecisionResult } from "./request-approval-contracts.js";
+/** Session storage owns every wait. This owner retains only actively running promises. */
+export declare class SavedRequestApprovals {
+    private readonly application;
+    private readonly controls;
+    private readonly activity;
+    private readonly publish;
+    readonly ownerEpoch: `${string}-${string}-${string}-${string}-${string}`;
+    private readonly retiring;
+    private readonly store;
+    constructor(application: RuntimeApplication, controls: LocalRequestControls, activity: LocalRuntimeOwnerActivity, publish: (event: unknown) => void);
+    activation(): {
+        ownerEpoch: `${string}-${string}-${string}-${string}-${string}`;
+        activationId: `${string}-${string}-${string}-${string}-${string}`;
+    };
+    track<T>(requestId: string, operation: () => Promise<T>): Promise<T>;
+    recover(): Promise<void>;
+    list(sessionId?: unknown): Promise<LocalPendingToolApproval[]>;
+    attach(requestId: unknown, sessionId: unknown, peer: LocalRuntimePeer): Promise<boolean>;
+    cancel(requestId: unknown, sessionId: unknown, input: unknown): Promise<boolean>;
+    decide(input: unknown, peer: LocalRuntimePeer): Promise<LocalToolApprovalDecisionResult | undefined>;
+    private commitDecisionAndResume;
+    private resume;
+    private emit;
+    private interruptUncertainClaim;
+}

package/dist/src/runtime/local-host/saved-approvals.js

@@ -0,0 +1,334 @@
+import { randomUUID } from "node:crypto";
+import { REQUEST_APPROVAL_SNAPSHOT, } from "../request/approval-wait/snapshot.js";
+import { validateApprovalResume } from "../request/approval-wait/preflight.js";
+import { hasApprovalDecisionIdentity } from "./app-request-approvals.js";
+import { traceDebug } from "../observability/debug-logger.js";
+function hasDurableIdentity(input) {
+    return (typeof input.generation === "string" &&
+        input.generation.length > 0 &&
+        typeof input.waitId === "string" &&
+        input.waitId.length > 0 &&
+        Number.isSafeInteger(input.revision) &&
+        typeof input.commandId === "string" &&
+        input.commandId.length > 0);
+}
+function expectation(current) {
+    if (!current.wait)
+        throw new Error("request_not_waiting");
+    return {
+        requestId: current.requestId,
+        generation: current.generation,
+        revision: current.revision,
+        waitId: current.wait.waitId,
+    };
+}
+/** Session storage owns every wait. This owner retains only actively running promises. */
+export class SavedRequestApprovals {
+    application;
+    controls;
+    activity;
+    publish;
+    ownerEpoch = randomUUID();
+    retiring = new Map();
+    store;
+    constructor(application, controls, activity, publish) {
+        this.application = application;
+        this.controls = controls;
+        this.activity = activity;
+        this.publish = publish;
+        this.store = application.services.sessions.requestLifecycle;
+    }
+    activation() {
+        return { ownerEpoch: this.ownerEpoch, activationId: randomUUID() };
+    }
+    async track(requestId, operation) {
+        if (this.retiring.has(requestId))
+            throw new Error("local_runtime_request_already_active");
+        const pending = operation();
+        this.retiring.set(requestId, pending);
+        try {
+            return await pending;
+        }
+        finally {
+            if (this.retiring.get(requestId) === pending)
+                this.retiring.delete(requestId);
+        }
+    }
+    async recover() {
+        if (!this.store)
+            return;
+        const sessions = await this.application.services.sessions.getAllSessions();
+        for (const session of sessions) {
+            for (const request of session.requests ?? []) {
+                if (request.status !== "streaming" || !request.lifecycle)
+                    continue;
+                const current = await this.store.get(session.id, request.requestId);
+                if (!current?.activation || current.status !== "streaming")
+                    continue;
+                await this.store.interruptActivation(session.id, {
+                    expected: {
+                        requestId: current.requestId,
+                        generation: current.generation,
+                        revision: current.revision,
+                        ...current.activation,
+                    },
+                    commandId: randomUUID(),
+                    message: {
+                        content: "The running task was interrupted by a runtime restart.",
+                    },
+                });
+            }
+        }
+    }
+    async list(sessionId) {
+        if (!this.store)
+            return [];
+        if (sessionId !== undefined && typeof sessionId !== "string")
+            return [];
+        const waiting = await this.store.listWaiting(sessionId);
+        return waiting.flatMap((current) => {
+            const wait = current.wait;
+            return wait.approvals
+                .filter((approval) => !current.decisionReceipts.some((receipt) => receipt.waitId === wait.waitId &&
+                receipt.approvalId === approval.approvalId))
+                .map((approval) => ({
+                sessionId: current.sessionId,
+                request: structuredClone(approval.presentation),
+                wait: {
+                    generation: current.generation,
+                    waitId: wait.waitId,
+                    revision: current.revision,
+                },
+            }));
+        });
+    }
+    async attach(requestId, sessionId, peer) {
+        if (!this.store ||
+            typeof requestId !== "string" ||
+            typeof sessionId !== "string")
+            return false;
+        const current = await this.store.get(sessionId, requestId);
+        if (current?.status !== "awaiting_approval")
+            return false;
+        // Readiness means this saved response can be read; it starts no execution.
+        await peer.callClient("request.accepted", [requestId]);
+        return true;
+    }
+    async cancel(requestId, sessionId, input) {
+        if (!this.store ||
+            typeof requestId !== "string" ||
+            typeof sessionId !== "string")
+            return false;
+        const current = await this.store.get(sessionId, requestId);
+        const command = input;
+        if (!current ||
+            !command ||
+            command.generation !== current.generation ||
+            typeof command.waitId !== "string" ||
+            !Number.isSafeInteger(command.revision) ||
+            typeof command.commandId !== "string" ||
+            !command.commandId)
+            return false;
+        const result = await this.store.cancelWait(sessionId, {
+            expected: {
+                requestId,
+                generation: command.generation,
+                revision: command.revision,
+                waitId: command.waitId,
+            },
+            commandId: command.commandId,
+            message: { content: "I stopped the task at your request." },
+        });
+        if (result.accepted)
+            this.emit(result.events, sessionId);
+        return result.accepted;
+    }
+    async decide(input, peer) {
+        if (!this.store || !hasApprovalDecisionIdentity(input))
+            return undefined;
+        const current = await this.store.get(input.sessionId, input.requestId);
+        const isDurable = current?.status === "awaiting_approval" || input.waitId !== undefined;
+        if (!isDurable)
+            return undefined;
+        if (!hasDurableIdentity(input))
+            return { accepted: false, reason: "invalid_approval_decision" };
+        const previous = await this.store.getDecisionReceipt(input.sessionId, input.requestId, input.generation, input.commandId);
+        if (previous) {
+            const matches = previous.waitId === input.waitId &&
+                previous.approvalId === input.approvalId &&
+                previous.approved === input.approved &&
+                previous.reason === input.reason;
+            return matches
+                ? { accepted: true, duplicate: true }
+                : { accepted: false, reason: "approval_conflict" };
+        }
+        if (!current?.wait || current.status !== "awaiting_approval")
+            return { accepted: false, reason: "approval_not_pending" };
+        const expected = expectation(current);
+        if (expected.generation !== input.generation ||
+            expected.waitId !== input.waitId ||
+            expected.revision !== input.revision)
+            return { accepted: false, reason: "approval_conflict" };
+        const remaining = current.wait.approvals.filter((approval) => !current.decisionReceipts.some((receipt) => receipt.waitId === input.waitId &&
+            receipt.approvalId === approval.approvalId));
+        if (!remaining.some((approval) => approval.approvalId === input.approvalId))
+            return { accepted: false, reason: "approval_not_pending" };
+        const finalDecision = remaining.length === 1;
+        let snapshot;
+        if (finalDecision) {
+            await this.retiring.get(input.requestId)?.catch(() => undefined);
+            try {
+                const reference = await this.store.getContinuation(input.sessionId, expected);
+                if (!reference)
+                    return { accepted: false, reason: "approval_conflict" };
+                if (reference.schema !== REQUEST_APPROVAL_SNAPSHOT ||
+                    reference.version !== 1)
+                    return { accepted: false, reason: "approval_resume_unavailable" };
+                snapshot = (await this.store.readContinuation(input.sessionId, reference));
+                await validateApprovalResume(this.application.services, snapshot, current);
+            }
+            catch (error) {
+                traceDebug("runtime.approvals", "resume.preflight_failed", {
+                    requestId: input.requestId,
+                    error: error instanceof Error ? error.message : "unknown",
+                });
+                return { accepted: false, reason: "approval_resume_unavailable" };
+            }
+        }
+        const commit = () => this.commitDecisionAndResume(input, expected, snapshot, peer);
+        const admission = this.application.services.requestAdmission;
+        // Acquire admission while the saved wait still blocks the scheduler. The
+        // resumed handler enters the same admission synchronously before release.
+        return admission ? admission.run(input.sessionId, commit, true) : commit();
+    }
+    async commitDecisionAndResume(input, expected, snapshot, peer) {
+        this.activity.assertAcceptingRequests();
+        const activation = snapshot ? this.activation() : undefined;
+        let result;
+        try {
+            result = await this.store.commitDecision(input.sessionId, {
+                expected,
+                commandId: input.commandId,
+                approvalId: input.approvalId,
+                approved: input.approved,
+                ...(input.reason !== undefined ? { reason: input.reason } : {}),
+                ...(activation ? { resumeActivation: activation } : {}),
+            });
+        }
+        catch (error) {
+            // An uncertain storage acknowledgement never authorizes dispatch.
+            await this.interruptUncertainClaim(input);
+            throw error;
+        }
+        if (!result.accepted)
+            return { accepted: false, reason: "approval_conflict" };
+        this.emit(result.events, input.sessionId);
+        if (snapshot && activation && !result.duplicate) {
+            const resumed = result.current;
+            const acceptedSnapshot = snapshot;
+            void this.activity
+                .run(() => this.track(input.requestId, () => this.resume(acceptedSnapshot, resumed, expected, peer)))
+                .catch(async (error) => {
+                try {
+                    await this.interruptUncertainClaim(input);
+                }
+                catch (interruptionError) {
+                    traceDebug("runtime.approvals", "resume.interruption_unconfirmed", {
+                        requestId: input.requestId,
+                        error: interruptionError instanceof Error
+                            ? interruptionError.message
+                            : "unknown",
+                    });
+                }
+                traceDebug("runtime.approvals", "resume.failed", {
+                    requestId: input.requestId,
+                    error: error instanceof Error ? error.message : "unknown",
+                });
+            });
+        }
+        return { accepted: true, ...(result.duplicate ? { duplicate: true } : {}) };
+    }
+    async resume(snapshot, current, consumedWait, peer) {
+        const { requestId, sessionId } = current;
+        const options = this.controls.ordinary(requestId, peer, { approvalAvailable: true }, sessionId, consumedWait);
+        const decisions = snapshot.runner.preparedGroup.entries.flatMap((entry) => {
+            // The consumed wait has been removed; exact approval IDs bind its saved actions.
+            const saved = current.decisionReceipts.find((item) => item.waitId === consumedWait.waitId &&
+                item.approvalId === entry.approvalRequest?.approvalId);
+            return saved
+                ? [
+                    {
+                        approvalId: saved.approvalId,
+                        actionFingerprint: entry.actionFingerprint,
+                        recorded: true,
+                        decision: {
+                            approved: saved.approved,
+                            ...(saved.reason !== undefined ? { reason: saved.reason } : {}),
+                        },
+                    },
+                ]
+                : [];
+        });
+        const ws = {
+            send: (data) => this.emit([JSON.parse(data)], sessionId),
+        };
+        try {
+            await this.application.requests.handle(ws, {
+                type: "run_request",
+                requestId,
+                sessionId,
+                text: snapshot.originalPrompt,
+                agentMode: snapshot.seed.agentMode,
+                modelPreference: snapshot.seed.modelPreference,
+                toolPermissionMode: snapshot.seed.toolPermissionMode,
+            }, {
+                ...options,
+                approvalExecution: {
+                    activation: current.activation,
+                    resume: { snapshot, current, decisions },
+                },
+            });
+        }
+        finally {
+            this.controls.finish(requestId);
+        }
+    }
+    emit(events, sessionId) {
+        for (const event of events)
+            this.publish({
+                type: "request.event",
+                event: {
+                    ...event,
+                    sessionId,
+                    environment: this.application.services.config.runtimeId,
+                    requestOrigin: "approval",
+                },
+            });
+    }
+    async interruptUncertainClaim(input) {
+        const current = await this.store.get(input.sessionId, input.requestId);
+        if (current?.status !== "streaming" || !current.activation)
+            return;
+        if (current.generation !== input.generation)
+            return;
+        const receipt = current.decisionReceipts.find((value) => value.commandId === input.commandId);
+        if (receipt?.activation?.activationId !== current.activation.activationId)
+            return;
+        if (receipt.activation.ownerEpoch !== this.ownerEpoch)
+            return;
+        const result = await this.store.interruptActivation(input.sessionId, {
+            expected: {
+                requestId: current.requestId,
+                generation: current.generation,
+                revision: current.revision,
+                ...current.activation,
+            },
+            commandId: randomUUID(),
+            message: {
+                content: "The running task was interrupted before its outcome was confirmed.",
+            },
+        });
+        if (result.accepted)
+            this.emit(result.events, input.sessionId);
+    }
+}

package/dist/src/runtime/local-host/startup-connection.d.ts

@@ -1,5 +1,8 @@
 import type { LocalRuntimeConnectionOptions, LocalRuntimeEndpoint } from "./contracts.js";
 import { LocalRuntimeRpcPeer } from "./rpc-peer.js";
-export declare function connectToPublishedRuntimeOwner(options: Pick<LocalRuntimeConnectionOptions, "directory" | "identity">, deadline: number): Promise<LocalRuntimeRpcPeer | undefined>;
+export declare function connectToPublishedRuntimeOwner(options: Pick<LocalRuntimeConnectionOptions, "directory" | "identity">, deadline: number): Promise<{
+    peer: LocalRuntimeRpcPeer;
+    endpoint: LocalRuntimeEndpoint;
+} | undefined>;
 export declare function waitForRuntimeOwnerElection(deadline: number): Promise<void>;
 export declare function connectToRuntimeOwner(endpoint: LocalRuntimeEndpoint, deadline: number): Promise<LocalRuntimeRpcPeer>;

package/dist/src/runtime/local-host/startup-connection.js

@@ -10,7 +10,7 @@ export async function connectToPublishedRuntimeOwner(options, deadline) {
         return undefined;
     assertRuntimeOwnerIdentity(endpoint, options.identity);
     try {
-        return await connectToRuntimeOwner(endpoint, deadline);
+        return { peer: await connectToRuntimeOwner(endpoint, deadline), endpoint };
     }
     catch (error) {
         if (!isTransientRuntimeOwnerHandshakeFailure(error))

package/dist/src/runtime/local-host/transport.js

@@ -2,6 +2,7 @@ import { join } from "node:path";
 import { acquireFileLock } from "../adapters/long-term-memory/file-lock/acquisition.js";
 import { ensurePrivateRuntimeDirectory, removeLocalRuntimeEndpoint, writeLocalRuntimeEndpoint, } from "./endpoint.js";
 import { startLocalRuntimeOwnerServer } from "./owner-server.js";
+import { createReconnectableRuntimeConnection } from "./reconnectable-connection.js";
 import { releaseRuntimeOwnerWhenIdle } from "./owner-retirement.js";
 import { connectToPublishedRuntimeOwner, connectToRuntimeOwner, waitForRuntimeOwnerElection, } from "./startup-connection.js";
 export async function createLocalRuntimeConnection(options) {
@@ -13,11 +14,9 @@ export async function createLocalRuntimeConnection(options) {
         const release = await tryAcquireRuntimeOwner(options.directory);
         if (release)
             return establishRuntimeOwner(options, release);
-        const peer = await connectToPublishedRuntimeOwner(options, deadline);
-        if (peer)
-            return createConnection(peer, "client", async () => {
-                peer.close();
-            });
+        const connected = await connectToPublishedRuntimeOwner(options, deadline);
+        if (connected)
+            return createReconnectableRuntimeConnection(connected.peer, connected.endpoint, "client");
         await waitForRuntimeOwnerElection(deadline);
     }
 }
@@ -29,7 +28,7 @@ async function establishRuntimeOwner(options, release) {
         host = await startLocalRuntimeOwnerServer(options.identity, owner);
         await writeLocalRuntimeEndpoint(options.directory, host.endpoint);
         const peer = await connectToRuntimeOwner(host.endpoint, Date.now() + 10_000);
-        return createConnection(peer, "owner", async () => {
+        return createReconnectableRuntimeConnection(peer, host.endpoint, "owner", async () => {
             try {
                 await host.close();
             }
@@ -58,32 +57,6 @@ async function establishRuntimeOwner(options, release) {
         throw error;
     }
 }
-function createConnection(peer, ownership, close, isOwnerIdle = () => false) {
-    let shutdown;
-    return Object.freeze({
-        ownership,
-        isOwnerIdle: () => !shutdown && isOwnerIdle(),
-        closeIfIdle: () => {
-            if (ownership !== "owner")
-                return Promise.resolve(false);
-            if (shutdown)
-                return shutdown.then(() => true);
-            if (!isOwnerIdle())
-                return Promise.resolve(false);
-            // close() synchronously closes host intake before its first await.
-            shutdown = close();
-            return shutdown.then(() => true);
-        },
-        call: (method, args) => peer.call(method, args),
-        subscribe: (listener) => peer.subscribe(listener),
-        setClientHandler: (handler) => peer.setHandler(handler),
-        onClose: (listener) => peer.onClose(listener),
-        close: () => {
-            shutdown ??= close();
-            return shutdown;
-        },
-    });
-}
 async function tryAcquireRuntimeOwner(directory) {
     try {
         return await acquireFileLock(join(directory, "owner"), {

package/dist/src/runtime/long-term-memory/automatic-management.d.ts

@@ -0,0 +1,3 @@
+import type { LongTermMemoryRecord } from "./contracts.js";
+/** Legacy records stay protected when their manual-edit history is unknown. */
+export declare function canAutomaticallyManageMemory(record: LongTermMemoryRecord): boolean;

package/dist/src/runtime/long-term-memory/automatic-management.js

@@ -0,0 +1,6 @@
+/** Legacy records stay protected when their manual-edit history is unknown. */
+export function canAutomaticallyManageMemory(record) {
+    if (record.provenance.kind === "manual")
+        return false;
+    return record.automaticManagement === "allowed";
+}

package/dist/src/runtime/long-term-memory/background-save-queue.js

@@ -52,6 +52,7 @@ function detachSave(save) {
         candidates: Object.freeze(save.candidates.map((candidate) => Object.freeze({
             content: candidate.content,
             tags: Object.freeze([...candidate.tags]),
+            ...(candidate.assessment ? { assessment: structuredClone(candidate.assessment) } : {}),
         }))),
         requestId: save.requestId,
         sessionId: save.sessionId,

package/dist/src/runtime/long-term-memory/candidate-preparation.d.ts

@@ -1,8 +1,7 @@
-import type { LongTermMemoryRecord, MemoryCandidate } from "./contracts.js";
+import type { MemoryCandidate } from "./contracts.js";
 export type PreparedMemoryCandidates = Readonly<{
     candidates: readonly MemoryCandidate[];
     rejectedCount: number;
     duplicateCount: number;
 }>;
 export declare function prepareMemoryCandidates(candidates: readonly MemoryCandidate[]): PreparedMemoryCandidates;
-export declare function indexMemoryRecordsByContent(records: readonly LongTermMemoryRecord[]): ReadonlyMap<string, LongTermMemoryRecord>;

package/dist/src/runtime/long-term-memory/candidate-preparation.js

@@ -13,13 +13,17 @@ export function prepareMemoryCandidates(candidates) {
         const key = normalizeMemoryText(candidate.content);
         const duplicate = byContent.get(key);
         if (!duplicate) {
-            byContent.set(key, candidate);
+            byContent.set(key, { ...candidate, ...(rawCandidate.assessment ? { assessment: rawCandidate.assessment } : {}) });
             continue;
         }
         duplicateCount += 1;
+        const assessment = rawCandidate.assessment?.explicitlyRequested
+            ? rawCandidate.assessment
+            : duplicate.assessment;
         byContent.set(key, Object.freeze({
             content: duplicate.content,
             tags: mergeMemoryTags(duplicate.tags, candidate.tags),
+            ...(assessment ? { assessment } : {}),
         }));
     }
     return Object.freeze({
@@ -28,9 +32,6 @@ export function prepareMemoryCandidates(candidates) {
         duplicateCount,
     });
 }
-export function indexMemoryRecordsByContent(records) {
-    return new Map(records.map((record) => [normalizeMemoryText(record.content), record]));
-}
 function shouldRejectCandidate(candidate) {
     return !candidate || containsSensitiveMemoryCandidateData(candidate);
 }

package/dist/src/runtime/long-term-memory/candidate-processing.d.ts

@@ -1,9 +1,11 @@
-import type { LongTermMemoryEmbeddingClient, LongTermMemoryRepository, LongTermMemoryRequestContext, MemoryCandidate, MemoryCandidateProcessingResult } from "./contracts.js";
+import type { LongTermMemoryRepository, LongTermMemoryRequestContext, MemoryCandidate, MemoryCandidateProcessingResult } from "./contracts.js";
+import type { LongTermMemoryManagementService } from "./management/contracts.js";
+import type { LearningMemoryService } from "./maturation/contracts.js";
 export declare function processMemoryCandidates(params: {
     repository: LongTermMemoryRepository;
-    embeddings: LongTermMemoryEmbeddingClient;
+    learning: LearningMemoryService;
+    management: Pick<LongTermMemoryManagementService, "create" | "update">;
     candidates: readonly MemoryCandidate[];
     context: LongTermMemoryRequestContext;
     now?: () => Date;
-    createId?: () => string;
 }): Promise<MemoryCandidateProcessingResult>;