@botbotgo/agent-harness 0.0.475 → 0.0.476

package/dist/runtime/harness/system/runtime-memory-records.js

@@ -1,577 +1,11 @@
-import { createHash } from "node:crypto";
-import { normalizeLangMemMemoryKind } from "./runtime-memory-policy.js";
-const MEMORY_SCOPES = ["session", "agent", "workspace", "user", "project"];
-function normalizeScope(scope) {
-    if (scope === "agent" || scope === "workspace" || scope === "user" || scope === "project") {
-        return scope;
-    }
-    return "session";
-}
-function normalizeSummary(candidate) {
-    const value = candidate.summary?.trim() || candidate.content.trim().split("\n")[0] || candidate.content.trim();
-    return value.slice(0, 240);
-}
-function createFingerprint(input) {
-    return createHash("sha256").update(input).digest("hex");
-}
-function normalizeConfidence(value) {
-    if (typeof value !== "number" || Number.isNaN(value)) {
-        return 0.5;
-    }
-    return Math.min(1, Math.max(0, value));
-}
-function normalizeSourceRef(value) {
-    return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;
-}
-function normalizeOperationalRule(rule) {
-    if (!rule) {
-        return undefined;
-    }
-    const trigger = typeof rule.trigger === "string" ? rule.trigger.trim() : "";
-    const action = typeof rule.action === "string" ? rule.action.trim() : "";
-    const target = typeof rule.target === "string" ? rule.target.trim() : "";
-    if (!trigger || !action || !target) {
-        return undefined;
-    }
-    return {
-        trigger,
-        action,
-        target,
-        ...(rule.effect === "apply" || rule.effect === "invalidate" ? { effect: rule.effect } : {}),
-    };
-}
-function normalizeKnowledgeMutation(mutation) {
-    if (!mutation || typeof mutation !== "object") {
-        return undefined;
-    }
-    const identity = typeof mutation.identity === "string" ? mutation.identity.trim() : "";
-    if (!identity) {
-        return undefined;
-    }
-    const operation = mutation.operation === "update" || mutation.operation === "delete" ? mutation.operation : "create";
-    return { identity, operation };
-}
-function inferKnowledgeMutation(candidate) {
-    const explicit = normalizeKnowledgeMutation(candidate.knowledgeMutation);
-    if (explicit) {
-        return explicit;
-    }
-    const operationalRule = normalizeOperationalRule(candidate.operationalRule);
-    if (operationalRule) {
-        return {
-            identity: `rule:${createFingerprint([operationalRule.trigger, operationalRule.action, operationalRule.target].join("\n"))}`,
-            operation: operationalRule.effect === "invalidate" ? "delete" : "create",
-        };
-    }
-    return undefined;
-}
-function createCanonicalKey(candidate, kind, scope) {
-    const knowledgeMutation = normalizeKnowledgeMutation(candidate.knowledgeMutation);
-    if (knowledgeMutation) {
-        return `${kind}:${scope}:knowledge:${createFingerprint(knowledgeMutation.identity)}`;
-    }
-    const operationalRule = normalizeOperationalRule(candidate.operationalRule);
-    if (operationalRule) {
-        return `${kind}:${scope}:rule:${createFingerprint([operationalRule.trigger, operationalRule.action, operationalRule.target].join("\n"))}`;
-    }
-    const sourceRef = normalizeSourceRef(candidate.sourceRef);
-    if (sourceRef) {
-        return `${kind}:${scope}:source:${createFingerprint(sourceRef)}`;
-    }
-    const base = normalizeSummary(candidate).toLowerCase().replace(/\s+/g, " ").trim();
-    return `${kind}:${scope}:summary:${createFingerprint(base)}`;
-}
-function buildScopeNamespace(scope) {
-    return ["memories", "records", scope];
-}
-function buildCanonicalIndexNamespace(scope) {
-    return ["memories", "indexes", "canonical", scope];
-}
-function buildSourceRefIndexNamespace(scope) {
-    return ["memories", "indexes", "source-ref", scope];
-}
-function normalizeTextForCompare(value) {
-    return value.toLowerCase().replace(/\s+/g, " ").trim();
-}
-function tokenize(value) {
-    return new Set(value
-        .toLowerCase()
-        .split(/[^a-z0-9_]+/i)
-        .map((token) => token.trim())
-        .filter((token) => token.length > 2));
-}
-function jaccardSimilarity(left, right) {
-    const leftTokens = tokenize(left);
-    const rightTokens = tokenize(right);
-    if (leftTokens.size === 0 || rightTokens.size === 0) {
-        return 0;
-    }
-    let intersection = 0;
-    for (const token of leftTokens) {
-        if (rightTokens.has(token)) {
-            intersection += 1;
-        }
-    }
-    const union = new Set([...leftTokens, ...rightTokens]).size;
-    return union === 0 ? 0 : intersection / union;
-}
-function hasNegationSignal(value) {
-    const normalized = ` ${normalizeTextForCompare(value)} `;
-    return (normalized.includes(" not ") ||
-        normalized.includes(" no ") ||
-        normalized.includes(" never ") ||
-        normalized.includes(" without ") ||
-        normalized.includes(" do not ") ||
-        normalized.includes(" does not ") ||
-        normalized.includes(" did not "));
-}
-function mergeUniqueStrings(left, right) {
-    return Array.from(new Set([...left, ...right].filter((item) => item.trim().length > 0)));
-}
-function mergeRecordContent(left, right) {
-    const normalizedLeft = normalizeTextForCompare(left);
-    const normalizedRight = normalizeTextForCompare(right);
-    if (normalizedLeft === normalizedRight) {
-        return left;
-    }
-    if (normalizedLeft.includes(normalizedRight)) {
-        return left;
-    }
-    if (normalizedRight.includes(normalizedLeft)) {
-        return right;
-    }
-    return `${left.trim()}\n\n${right.trim()}`;
-}
-function createMemoryRecord(candidate, options) {
-    const kind = normalizeLangMemMemoryKind(candidate.kind);
-    const scope = normalizeScope(candidate.scope);
-    const canonicalKey = createCanonicalKey(candidate, kind, scope);
-    const id = createFingerprint([
-        canonicalKey,
-        candidate.content.trim(),
-        options.sessionId,
-        options.requestId,
-        options.agentId,
-        options.recordedAt,
-    ].join("\n"));
-    const sourceRef = normalizeSourceRef(candidate.sourceRef);
-    const operationalRule = normalizeOperationalRule(candidate.operationalRule);
-    const knowledgeMutation = inferKnowledgeMutation(candidate);
-    return {
-        id,
-        canonicalKey,
-        kind,
-        scope,
-        content: candidate.content.trim(),
-        summary: normalizeSummary(candidate),
-        status: "active",
-        confidence: normalizeConfidence(candidate.confidence),
-        createdAt: options.recordedAt,
-        observedAt: candidate.observedAt ?? options.recordedAt,
-        lastConfirmedAt: options.recordedAt,
-        sourceType: candidate.sourceType?.trim() || "tool-output",
-        sourceRefs: sourceRef ? [sourceRef] : [],
-        tags: candidate.tags ?? [],
-        ...(knowledgeMutation
-            ? {
-                knowledgeIdentity: knowledgeMutation.identity,
-                knowledgeOperation: knowledgeMutation.operation,
-            }
-            : {}),
-        ...(operationalRule ? { operationalRule } : {}),
-        provenance: {
-            sessionId: options.sessionId,
-            requestId: options.requestId,
-            agentId: options.agentId,
-            workspaceId: options.workspaceId,
-            userId: options.userId,
-            projectId: options.projectId,
-            ...(candidate.provenance ?? {}),
-        },
-        revision: 1,
-        supersedes: [],
-        conflictsWith: [],
-    };
-}
-function isSameRecordContent(left, right) {
-    return normalizeTextForCompare(left.content) === normalizeTextForCompare(right.content);
-}
-function refreshRecord(existing, incoming, recordedAt) {
-    return {
-        ...existing,
-        summary: incoming.summary.length > existing.summary.length ? incoming.summary : existing.summary,
-        confidence: Math.max(existing.confidence, incoming.confidence),
-        observedAt: incoming.observedAt,
-        lastConfirmedAt: recordedAt,
-        sourceRefs: mergeUniqueStrings(existing.sourceRefs, incoming.sourceRefs),
-        tags: mergeUniqueStrings(existing.tags, incoming.tags),
-        provenance: {
-            ...existing.provenance,
-            refreshedFrom: incoming.provenance,
-            lastRefreshRequestId: incoming.provenance.requestId,
-            lastRefreshSessionId: incoming.provenance.sessionId,
-        },
-        revision: existing.revision + 1,
-    };
-}
-function mergeRecord(existing, incoming, recordedAt) {
-    return {
-        ...existing,
-        content: mergeRecordContent(existing.content, incoming.content),
-        summary: incoming.summary.length >= existing.summary.length ? incoming.summary : existing.summary,
-        confidence: Math.max(existing.confidence, incoming.confidence),
-        observedAt: incoming.observedAt,
-        lastConfirmedAt: recordedAt,
-        sourceRefs: mergeUniqueStrings(existing.sourceRefs, incoming.sourceRefs),
-        tags: mergeUniqueStrings(existing.tags, incoming.tags),
-        provenance: {
-            ...existing.provenance,
-            mergedFrom: incoming.provenance,
-            lastMergeRequestId: incoming.provenance.requestId,
-            lastMergeSessionId: incoming.provenance.sessionId,
-        },
-        revision: existing.revision + 1,
-    };
-}
-function markConflicted(record, conflictingRecordId, recordedAt) {
-    return {
-        ...record,
-        status: "conflicted",
-        lastConfirmedAt: recordedAt,
-        conflictsWith: mergeUniqueStrings(record.conflictsWith, [conflictingRecordId]),
-        revision: record.revision + 1,
-    };
-}
-function createReviewRecord(existing, incoming, recordedAt) {
-    return {
-        ...incoming,
-        status: "pending_review",
-        conflictsWith: mergeUniqueStrings(incoming.conflictsWith, [existing.id]),
-        lastConfirmedAt: recordedAt,
-    };
-}
-function archiveRecord(record, incomingRecordId, recordedAt) {
-    return {
-        ...record,
-        status: "archived",
-        lastConfirmedAt: recordedAt,
-        supersedes: mergeUniqueStrings(record.supersedes, [incomingRecordId]),
-        revision: record.revision + 1,
-    };
-}
-async function listStoredRecords(store, scope) {
-    const scopes = scope ? [scope] : MEMORY_SCOPES;
-    const docs = await Promise.all(scopes.map((currentScope) => store.search(buildScopeNamespace(currentScope))));
-    return docs
-        .flat()
-        .map((entry) => entry.value)
-        .filter((record) => typeof record?.id === "string" && typeof record.content === "string");
-}
-function findMatchingRecord(existingRecords, incoming) {
-    const exact = existingRecords.find((record) => record.scope === incoming.scope && isSameRecordContent(record, incoming));
-    if (exact) {
-        return exact;
-    }
-    const sourceRefMatch = existingRecords.find((record) => record.scope === incoming.scope &&
-        incoming.sourceRefs.some((sourceRef) => record.sourceRefs.includes(sourceRef)));
-    if (sourceRefMatch) {
-        return sourceRefMatch;
-    }
-    return existingRecords.find((record) => record.scope === incoming.scope && record.canonicalKey === incoming.canonicalKey);
-}
-function evaluateDecision(existing, incoming, recordedAt) {
-    if (!existing) {
-        return {
-            decision: {
-                action: "store",
-                reason: "Stored as a new durable memory record.",
-                recordId: incoming.id,
-                kind: incoming.kind,
-                scope: incoming.scope,
-                confidence: incoming.confidence,
-                maintenance: "dedupe",
-                reviewRequired: false,
-            },
-            primaryRecord: incoming,
-            additionalRecords: [],
-        };
-    }
-    if (isSameRecordContent(existing, incoming)) {
-        const refreshed = refreshRecord(existing, incoming, recordedAt);
-        return {
-            decision: {
-                action: "refresh",
-                reason: "Refreshed an exact durable memory match.",
-                recordId: refreshed.id,
-                kind: refreshed.kind,
-                scope: refreshed.scope,
-                confidence: refreshed.confidence,
-                maintenance: "none",
-                reviewRequired: false,
-            },
-            primaryRecord: refreshed,
-            additionalRecords: [],
-        };
-    }
-    if (existing.canonicalKey === incoming.canonicalKey ||
-        incoming.sourceRefs.some((sourceRef) => existing.sourceRefs.includes(sourceRef))) {
-        if (existing.knowledgeIdentity && incoming.knowledgeIdentity && existing.knowledgeIdentity === incoming.knowledgeIdentity) {
-            const existingOperation = existing.knowledgeOperation ?? "create";
-            const incomingOperation = incoming.knowledgeOperation ?? "create";
-            if (existingOperation !== incomingOperation || !isSameRecordContent(existing, incoming)) {
-                const archivedExisting = archiveRecord(existing, incoming.id, recordedAt);
-                const activeIncoming = {
-                    ...incoming,
-                    supersedes: mergeUniqueStrings(incoming.supersedes, [existing.id]),
-                };
-                return {
-                    decision: {
-                        action: "supersede",
-                        reason: "Stored a newer knowledge mutation that supersedes the previous active state.",
-                        recordId: activeIncoming.id,
-                        kind: activeIncoming.kind,
-                        scope: activeIncoming.scope,
-                        confidence: activeIncoming.confidence,
-                        maintenance: "merge",
-                        reviewRequired: false,
-                    },
-                    primaryRecord: archivedExisting,
-                    additionalRecords: [activeIncoming],
-                };
-            }
-        }
-        if (hasNegationSignal(existing.content) !== hasNegationSignal(incoming.content)) {
-            const conflictedExisting = markConflicted(existing, incoming.id, recordedAt);
-            const pendingReview = createReviewRecord(conflictedExisting, incoming, recordedAt);
-            return {
-                decision: {
-                    action: "review",
-                    reason: "Detected conflicting durable memory with the same canonical identity.",
-                    recordId: pendingReview.id,
-                    kind: pendingReview.kind,
-                    scope: pendingReview.scope,
-                    confidence: pendingReview.confidence,
-                    maintenance: "review",
-                    reviewRequired: true,
-                },
-                primaryRecord: conflictedExisting,
-                additionalRecords: [pendingReview],
-            };
-        }
-        const similarity = jaccardSimilarity(existing.summary, incoming.summary);
-        if (similarity >= 0.45) {
-            const merged = mergeRecord(existing, incoming, recordedAt);
-            return {
-                decision: {
-                    action: "merge",
-                    reason: "Merged a matching durable memory record with compatible additions.",
-                    recordId: merged.id,
-                    kind: merged.kind,
-                    scope: merged.scope,
-                    confidence: merged.confidence,
-                    maintenance: "merge",
-                    reviewRequired: false,
-                },
-                primaryRecord: merged,
-                additionalRecords: [],
-            };
-        }
-        const conflictedExisting = markConflicted(existing, incoming.id, recordedAt);
-        const pendingReview = createReviewRecord(conflictedExisting, incoming, recordedAt);
-        return {
-            decision: {
-                action: "review",
-                reason: "Detected conflicting durable memory with the same canonical identity.",
-                recordId: pendingReview.id,
-                kind: pendingReview.kind,
-                scope: pendingReview.scope,
-                confidence: pendingReview.confidence,
-                maintenance: "review",
-                reviewRequired: true,
-            },
-            primaryRecord: conflictedExisting,
-            additionalRecords: [pendingReview],
-        };
-    }
-    return {
-        decision: {
-            action: "store",
-            reason: "Stored as a new durable memory record.",
-            recordId: incoming.id,
-            kind: incoming.kind,
-            scope: incoming.scope,
-            confidence: incoming.confidence,
-            maintenance: "dedupe",
-            reviewRequired: false,
-        },
-        primaryRecord: incoming,
-        additionalRecords: [],
-    };
-}
-async function putRecordWithIndexes(store, record, updatedAt) {
-    const canonicalKeyId = createFingerprint(record.canonicalKey);
-    await store.put(buildScopeNamespace(record.scope), `${record.id}.json`, record);
-    await store.put(buildCanonicalIndexNamespace(record.scope), `${canonicalKeyId}-${record.id}.json`, {
-        canonicalKey: record.canonicalKey,
-        recordId: record.id,
-        scope: record.scope,
-        kind: record.kind,
-        updatedAt,
-    });
-    await Promise.all(record.sourceRefs.map((sourceRef) => {
-        const sourceRefId = createFingerprint(sourceRef);
-        return store.put(buildSourceRefIndexNamespace(record.scope), `${sourceRefId}-${record.id}.json`, {
-            sourceRef,
-            recordId: record.id,
-            scope: record.scope,
-            kind: record.kind,
-            updatedAt,
-        });
-    }));
-}
-export function renderMemoryRecordsMarkdown(title, records) {
-    const lines = [`# ${title}`, ""];
-    if (records.length === 0) {
-        lines.push("(none)", "");
-        return lines.join("\n");
-    }
-    for (const record of records) {
-        lines.push(`## ${record.summary}`);
-        lines.push(`- kind: ${record.kind}`);
-        lines.push(`- scope: ${record.scope}`);
-        lines.push(`- status: ${record.status}`);
-        lines.push(`- confidence: ${record.confidence.toFixed(2)}`);
-        if (record.knowledgeIdentity) {
-            lines.push(`- knowledge_identity: ${record.knowledgeIdentity}`);
-            lines.push(`- knowledge_operation: ${record.knowledgeOperation ?? "create"}`);
-        }
-        if (record.operationalRule) {
-            lines.push(`- operational_rule: ${record.operationalRule.trigger} -> ${record.operationalRule.action}(${record.operationalRule.target}) [${record.operationalRule.effect ?? "apply"}]`);
-        }
-        if (record.tags.length > 0) {
-            lines.push(`- tags: ${record.tags.join(", ")}`);
-        }
-        lines.push("");
-        lines.push(record.content);
-        lines.push("");
-    }
-    return lines.join("\n");
-}
-export async function rebuildStructuredMemoryProjections(store, namespace, title, scope, maxEntries) {
-    const records = (await listStoredRecords(store, scope))
-        .filter((record) => record.status === "active")
-        .sort((left, right) => left.lastConfirmedAt.localeCompare(right.lastConfirmedAt))
-        .slice(-maxEntries);
-    await store.put(namespace, "structured-memory.md", {
-        content: `${renderMemoryRecordsMarkdown(title, records)}\n`,
-        items: records,
-    });
-    const grouped = new Map();
-    for (const record of records) {
-        const current = grouped.get(record.kind) ?? [];
-        current.push(record);
-        grouped.set(record.kind, current);
-    }
-    await Promise.all(Array.from(grouped.entries()).map(([kind, items]) => store.put(namespace, `${kind}.md`, {
-        content: `${renderMemoryRecordsMarkdown(`${title} (${kind})`, items)}\n`,
-        items,
-    })));
-}
-export async function listMemoryRecordsForScopes(store, scopes) {
-    const all = await Promise.all(scopes.map((scope) => listStoredRecords(store, scope)));
-    return all.flat();
-}
-export async function getMemoryRecord(store, scope, recordId) {
-    const entry = await store.get(buildScopeNamespace(scope), `${recordId}.json`);
-    const record = entry?.value;
-    if (typeof record !== "object" || !record || Array.isArray(record)) {
-        return null;
-    }
-    const candidate = record;
-    return typeof candidate.id === "string" && typeof candidate.content === "string" ? candidate : null;
-}
-export async function findMemoryRecordById(store, recordId) {
-    for (const scope of MEMORY_SCOPES) {
-        const record = await getMemoryRecord(store, scope, recordId);
-        if (record) {
-            return record;
-        }
-    }
-    return null;
-}
-async function deleteRecordIndexes(store, record) {
-    const [canonicalEntries, sourceRefEntries] = await Promise.all([
-        store.search(buildCanonicalIndexNamespace(record.scope)),
-        store.search(buildSourceRefIndexNamespace(record.scope)),
-    ]);
-    await Promise.all([
-        ...canonicalEntries
-            .filter((entry) => entry.value?.recordId === record.id)
-            .map((entry) => store.delete(entry.namespace, entry.key)),
-        ...sourceRefEntries
-            .filter((entry) => entry.value?.recordId === record.id)
-            .map((entry) => store.delete(entry.namespace, entry.key)),
-    ]);
-}
-export async function updateMemoryRecord(store, record, updatedAt) {
-    const existing = await getMemoryRecord(store, record.scope, record.id);
-    if (existing) {
-        await deleteRecordIndexes(store, existing);
-    }
-    await putRecordWithIndexes(store, record, updatedAt);
-    return record;
-}
-export async function removeMemoryRecord(store, scope, recordId) {
-    const existing = await getMemoryRecord(store, scope, recordId);
-    if (!existing) {
-        return null;
-    }
-    await deleteRecordIndexes(store, existing);
-    await store.delete(buildScopeNamespace(scope), `${recordId}.json`);
-    return existing;
-}
-export async function persistStructuredMemoryRecords(options) {
-    const sessionId = options.sessionId ?? options.legacySessionId;
-    const requestId = options.requestId ?? options.legacyRequestId;
-    if (!sessionId || !requestId) {
-        throw new Error("persistStructuredMemoryRecords requires sessionId/requestId");
-    }
-    const existingRecords = await listStoredRecords(options.store);
-    const persistedRecords = [];
-    const decisions = [];
-    for (const candidate of options.candidates) {
-        const incoming = createMemoryRecord(candidate, {
-            sessionId,
-            requestId,
-            agentId: options.agentId,
-            workspaceId: options.workspaceId,
-            userId: options.userId,
-            projectId: options.projectId,
-            recordedAt: options.recordedAt,
-        });
-        const existing = findMatchingRecord(existingRecords, incoming);
-        const evaluated = evaluateDecision(existing, incoming, options.recordedAt);
-        const recordsToWrite = [evaluated.primaryRecord, ...evaluated.additionalRecords];
-        for (const record of recordsToWrite) {
-            const priorRecord = existingRecords.find((item) => item.id === record.id);
-            if (priorRecord) {
-                await deleteRecordIndexes(options.store, priorRecord);
-            }
-            await putRecordWithIndexes(options.store, record, options.recordedAt);
-            const existingIndex = existingRecords.findIndex((item) => item.id === record.id);
-            if (existingIndex >= 0) {
-                existingRecords[existingIndex] = record;
-            }
-            else {
-                existingRecords.push(record);
-            }
-        }
-        await options.store.put(["memories", "decisions", sessionId, requestId], `${evaluated.decision.recordId ?? incoming.id}.json`, evaluated.decision);
-        decisions.push(evaluated.decision);
-        persistedRecords.push(...recordsToWrite);
-    }
-    return {
-        records: persistedRecords,
-        decisions,
-    };
-}
+import{createHash as N}from"node:crypto";import{normalizeLangMemMemoryKind as W}from"./runtime-memory-policy.js";const M=["session","agent","workspace","user","project"];function F(e){return e==="agent"||e==="workspace"||e==="user"||e==="project"?e:"session"}function S(e){return(e.summary?.trim()||e.content.trim().split(`
+`)[0]||e.content.trim()).slice(0,240)}function u(e){return N("sha256").update(e).digest("hex")}function T(e){return typeof e!="number"||Number.isNaN(e)?.5:Math.min(1,Math.max(0,e))}function b(e){return typeof e=="string"&&e.trim().length>0?e.trim():void 0}function R(e){if(!e)return;const t=typeof e.trigger=="string"?e.trigger.trim():"",n=typeof e.action=="string"?e.action.trim():"",r=typeof e.target=="string"?e.target.trim():"";if(!(!t||!n||!r))return{trigger:t,action:n,target:r,...e.effect==="apply"||e.effect==="invalidate"?{effect:e.effect}:{}}}function j(e){if(!e||typeof e!="object")return;const t=typeof e.identity=="string"?e.identity.trim():"";if(!t)return;const n=e.operation==="update"||e.operation==="delete"?e.operation:"create";return{identity:t,operation:n}}function _(e){const t=j(e.knowledgeMutation);if(t)return t;const n=R(e.operationalRule);if(n)return{identity:`rule:${u([n.trigger,n.action,n.target].join(`
+`))}`,operation:n.effect==="invalidate"?"delete":"create"}}function L(e,t,n){const r=j(e.knowledgeMutation);if(r)return`${t}:${n}:knowledge:${u(r.identity)}`;const o=R(e.operationalRule);if(o)return`${t}:${n}:rule:${u([o.trigger,o.action,o.target].join(`
+`))}`;const s=b(e.sourceRef);if(s)return`${t}:${n}:source:${u(s)}`;const i=S(e).toLowerCase().replace(/\s+/g," ").trim();return`${t}:${n}:summary:${u(i)}`}function m(e){return["memories","records",e]}function q(e){return["memories","indexes","canonical",e]}function A(e){return["memories","indexes","source-ref",e]}function p(e){return e.toLowerCase().replace(/\s+/g," ").trim()}function C(e){return new Set(e.toLowerCase().split(/[^a-z0-9_]+/i).map(t=>t.trim()).filter(t=>t.length>2))}function D(e,t){const n=C(e),r=C(t);if(n.size===0||r.size===0)return 0;let o=0;for(const i of n)r.has(i)&&(o+=1);const s=new Set([...n,...r]).size;return s===0?0:o/s}function z(e){const t=` ${p(e)} `;return t.includes(" not ")||t.includes(" no ")||t.includes(" never ")||t.includes(" without ")||t.includes(" do not ")||t.includes(" does not ")||t.includes(" did not ")}function f(e,t){return Array.from(new Set([...e,...t].filter(n=>n.trim().length>0)))}function x(e,t){const n=p(e),r=p(t);return n===r||n.includes(r)?e:r.includes(n)?t:`${e.trim()}
+
+${t.trim()}`}function B(e,t){const n=W(e.kind),r=F(e.scope),o=L(e,n,r),s=u([o,e.content.trim(),t.sessionId,t.requestId,t.agentId,t.recordedAt].join(`
+`)),i=b(e.sourceRef),c=R(e.operationalRule),a=_(e);return{id:s,canonicalKey:o,kind:n,scope:r,content:e.content.trim(),summary:S(e),status:"active",confidence:T(e.confidence),createdAt:t.recordedAt,observedAt:e.observedAt??t.recordedAt,lastConfirmedAt:t.recordedAt,sourceType:e.sourceType?.trim()||"tool-output",sourceRefs:i?[i]:[],tags:e.tags??[],...a?{knowledgeIdentity:a.identity,knowledgeOperation:a.operation}:{},...c?{operationalRule:c}:{},provenance:{sessionId:t.sessionId,requestId:t.requestId,agentId:t.agentId,workspaceId:t.workspaceId,userId:t.userId,projectId:t.projectId,...e.provenance??{}},revision:1,supersedes:[],conflictsWith:[]}}function w(e,t){return p(e.content)===p(t.content)}function H(e,t,n){return{...e,summary:t.summary.length>e.summary.length?t.summary:e.summary,confidence:Math.max(e.confidence,t.confidence),observedAt:t.observedAt,lastConfirmedAt:n,sourceRefs:f(e.sourceRefs,t.sourceRefs),tags:f(e.tags,t.tags),provenance:{...e.provenance,refreshedFrom:t.provenance,lastRefreshRequestId:t.provenance.requestId,lastRefreshSessionId:t.provenance.sessionId},revision:e.revision+1}}function U(e,t,n){return{...e,content:x(e.content,t.content),summary:t.summary.length>=e.summary.length?t.summary:e.summary,confidence:Math.max(e.confidence,t.confidence),observedAt:t.observedAt,lastConfirmedAt:n,sourceRefs:f(e.sourceRefs,t.sourceRefs),tags:f(e.tags,t.tags),provenance:{...e.provenance,mergedFrom:t.provenance,lastMergeRequestId:t.provenance.requestId,lastMergeSessionId:t.provenance.sessionId},revision:e.revision+1}}function K(e,t,n){return{...e,status:"conflicted",lastConfirmedAt:n,conflictsWith:f(e.conflictsWith,[t]),revision:e.revision+1}}function O(e,t,n){return{...t,status:"pending_review",conflictsWith:f(t.conflictsWith,[e.id]),lastConfirmedAt:n}}function Y(e,t,n){return{...e,status:"archived",lastConfirmedAt:n,supersedes:f(e.supersedes,[t]),revision:e.revision+1}}async function h(e,t){const n=t?[t]:M;return(await Promise.all(n.map(o=>e.search(m(o))))).flat().map(o=>o.value).filter(o=>typeof o?.id=="string"&&typeof o.content=="string")}function G(e,t){const n=e.find(o=>o.scope===t.scope&&w(o,t));if(n)return n;const r=e.find(o=>o.scope===t.scope&&t.sourceRefs.some(s=>o.sourceRefs.includes(s)));return r||e.find(o=>o.scope===t.scope&&o.canonicalKey===t.canonicalKey)}function J(e,t,n){if(!e)return{decision:{action:"store",reason:"Stored as a new durable memory record.",recordId:t.id,kind:t.kind,scope:t.scope,confidence:t.confidence,maintenance:"dedupe",reviewRequired:!1},primaryRecord:t,additionalRecords:[]};if(w(e,t)){const r=H(e,t,n);return{decision:{action:"refresh",reason:"Refreshed an exact durable memory match.",recordId:r.id,kind:r.kind,scope:r.scope,confidence:r.confidence,maintenance:"none",reviewRequired:!1},primaryRecord:r,additionalRecords:[]}}if(e.canonicalKey===t.canonicalKey||t.sourceRefs.some(r=>e.sourceRefs.includes(r))){if(e.knowledgeIdentity&&t.knowledgeIdentity&&e.knowledgeIdentity===t.knowledgeIdentity){const i=e.knowledgeOperation??"create",c=t.knowledgeOperation??"create";if(i!==c||!w(e,t)){const a=Y(e,t.id,n),d={...t,supersedes:f(t.supersedes,[e.id])};return{decision:{action:"supersede",reason:"Stored a newer knowledge mutation that supersedes the previous active state.",recordId:d.id,kind:d.kind,scope:d.scope,confidence:d.confidence,maintenance:"merge",reviewRequired:!1},primaryRecord:a,additionalRecords:[d]}}}if(z(e.content)!==z(t.content)){const i=K(e,t.id,n),c=O(i,t,n);return{decision:{action:"review",reason:"Detected conflicting durable memory with the same canonical identity.",recordId:c.id,kind:c.kind,scope:c.scope,confidence:c.confidence,maintenance:"review",reviewRequired:!0},primaryRecord:i,additionalRecords:[c]}}if(D(e.summary,t.summary)>=.45){const i=U(e,t,n);return{decision:{action:"merge",reason:"Merged a matching durable memory record with compatible additions.",recordId:i.id,kind:i.kind,scope:i.scope,confidence:i.confidence,maintenance:"merge",reviewRequired:!1},primaryRecord:i,additionalRecords:[]}}const o=K(e,t.id,n),s=O(o,t,n);return{decision:{action:"review",reason:"Detected conflicting durable memory with the same canonical identity.",recordId:s.id,kind:s.kind,scope:s.scope,confidence:s.confidence,maintenance:"review",reviewRequired:!0},primaryRecord:o,additionalRecords:[s]}}return{decision:{action:"store",reason:"Stored as a new durable memory record.",recordId:t.id,kind:t.kind,scope:t.scope,confidence:t.confidence,maintenance:"dedupe",reviewRequired:!1},primaryRecord:t,additionalRecords:[]}}async function E(e,t,n){const r=u(t.canonicalKey);await e.put(m(t.scope),`${t.id}.json`,t),await e.put(q(t.scope),`${r}-${t.id}.json`,{canonicalKey:t.canonicalKey,recordId:t.id,scope:t.scope,kind:t.kind,updatedAt:n}),await Promise.all(t.sourceRefs.map(o=>{const s=u(o);return e.put(A(t.scope),`${s}-${t.id}.json`,{sourceRef:o,recordId:t.id,scope:t.scope,kind:t.kind,updatedAt:n})}))}function P(e,t){const n=[`# ${e}`,""];if(t.length===0)return n.push("(none)",""),n.join(`
+`);for(const r of t)n.push(`## ${r.summary}`),n.push(`- kind: ${r.kind}`),n.push(`- scope: ${r.scope}`),n.push(`- status: ${r.status}`),n.push(`- confidence: ${r.confidence.toFixed(2)}`),r.knowledgeIdentity&&(n.push(`- knowledge_identity: ${r.knowledgeIdentity}`),n.push(`- knowledge_operation: ${r.knowledgeOperation??"create"}`)),r.operationalRule&&n.push(`- operational_rule: ${r.operationalRule.trigger} -> ${r.operationalRule.action}(${r.operationalRule.target}) [${r.operationalRule.effect??"apply"}]`),r.tags.length>0&&n.push(`- tags: ${r.tags.join(", ")}`),n.push(""),n.push(r.content),n.push("");return n.join(`
+`)}async function X(e,t,n,r,o){const s=(await h(e,r)).filter(c=>c.status==="active").sort((c,a)=>c.lastConfirmedAt.localeCompare(a.lastConfirmedAt)).slice(-o);await e.put(t,"structured-memory.md",{content:`${P(n,s)}
+`,items:s});const i=new Map;for(const c of s){const a=i.get(c.kind)??[];a.push(c),i.set(c.kind,a)}await Promise.all(Array.from(i.entries()).map(([c,a])=>e.put(t,`${c}.md`,{content:`${P(`${n} (${c})`,a)}
+`,items:a})))}async function Z(e,t){return(await Promise.all(t.map(r=>h(e,r)))).flat()}async function I(e,t,n){const o=(await e.get(m(t),`${n}.json`))?.value;if(typeof o!="object"||!o||Array.isArray(o))return null;const s=o;return typeof s.id=="string"&&typeof s.content=="string"?s:null}async function ee(e,t){for(const n of M){const r=await I(e,n,t);if(r)return r}return null}async function v(e,t){const[n,r]=await Promise.all([e.search(q(t.scope)),e.search(A(t.scope))]);await Promise.all([...n.filter(o=>o.value?.recordId===t.id).map(o=>e.delete(o.namespace,o.key)),...r.filter(o=>o.value?.recordId===t.id).map(o=>e.delete(o.namespace,o.key))])}async function te(e,t,n){const r=await I(e,t.scope,t.id);return r&&await v(e,r),await E(e,t,n),t}async function ne(e,t,n){const r=await I(e,t,n);return r?(await v(e,r),await e.delete(m(t),`${n}.json`),r):null}async function re(e){const t=e.sessionId??e.legacySessionId,n=e.requestId??e.legacyRequestId;if(!t||!n)throw new Error("persistStructuredMemoryRecords requires sessionId/requestId");const r=await h(e.store),o=[],s=[];for(const i of e.candidates){const c=B(i,{sessionId:t,requestId:n,agentId:e.agentId,workspaceId:e.workspaceId,userId:e.userId,projectId:e.projectId,recordedAt:e.recordedAt}),a=G(r,c),d=J(a,c,e.recordedAt),k=[d.primaryRecord,...d.additionalRecords];for(const l of k){const $=r.find(y=>y.id===l.id);$&&await v(e.store,$),await E(e.store,l,e.recordedAt);const g=r.findIndex(y=>y.id===l.id);g>=0?r[g]=l:r.push(l)}await e.store.put(["memories","decisions",t,n],`${d.decision.recordId??c.id}.json`,d.decision),s.push(d.decision),o.push(...k)}return{records:o,decisions:s}}export{ee as findMemoryRecordById,I as getMemoryRecord,Z as listMemoryRecordsForScopes,re as persistStructuredMemoryRecords,X as rebuildStructuredMemoryProjections,ne as removeMemoryRecord,P as renderMemoryRecordsMarkdown,te as updateMemoryRecord};