@oscharko-dev/keiko 0.2.0-beta.4 → 0.2.0-beta.6

package/node_modules/@oscharko-dev/keiko-server/dist/memory-handlers.js

@@ -1,4 +1,4 @@
-// Memory Center BFF route handlers (Issue #211 / Epic #204).
+// MemoriaViva BFF route handlers (Issue #211 / Epic #204).
 //
 // These handlers wire the /api/memory/* routes to the three memory packages:
 //   - @oscharko-dev/keiko-memory-vault   → persistence (list / get / update / delete)
@@ -15,15 +15,16 @@
 // Every response is redacted through `deps.redactor` before serialisation to honour D9.
 import { randomUUID } from "node:crypto";
 import { createMemoryVault, MemoryStorageError, } from "@oscharko-dev/keiko-memory-vault";
-import { GovernanceError, buildArchiveOperation, buildForgetOperations, buildPinOperation, buildUnpinOperation, selectMemoriesForForget, } from "@oscharko-dev/keiko-memory-governance";
-import { MEMORY_SCOPE_KINDS, MEMORY_STATUSES, MEMORY_TYPES, MEMORY_SENSITIVITIES, } from "@oscharko-dev/keiko-contracts";
+import { GovernanceError, buildArchiveOperation, buildConflictTransitions, buildCorrection, buildForgetOperations, buildPinOperation, buildUnpinOperation, detectConflictPair, selectMemoriesForForget, } from "@oscharko-dev/keiko-memory-governance";
+import { checkStatusTransition, MEMORY_SCOPE_KINDS, MEMORY_STATUSES, MEMORY_TYPES, MEMORY_SENSITIVITIES, validateMemoryScope, } from "@oscharko-dev/keiko-contracts";
 import { errorBody } from "./routes.js";
+import { auditRunIdFor, recordMemoryAudit } from "./memory-audit-handler.js";
 // ─── Constants ────────────────────────────────────────────────────────────────
 const MAX_MEMORY_BODY_BYTES = 64_000;
-const DEFAULT_REVIEWER_ID = "memory-center-ui";
+const DEFAULT_REVIEWER_ID = "memoriaviva-ui";
 const MAX_LIST_LIMIT = 200;
 const DEFAULT_LIST_LIMIT = 50;
-const REVIEW_QUEUE_STATUSES = ["proposed", "conflicted"];
+const REVIEW_QUEUE_STATUSES = ["proposed", "conflicted", "expired"];
 // ─── Type guards / helpers ─────────────────────────────────────────────────────
 // Sanitise GovernanceError into a code-keyed safe response body. GovernanceError.message
 // is composed as `GovernanceError(${code}): ${detail}` and can embed memory UUIDs from
@@ -74,6 +75,18 @@ function splitComma(raw) {
         .map((s) => s.trim())
         .filter((s) => s.length > 0);
 }
+function parseScope(raw) {
+    if (!isRecord(raw)) {
+        return { status: 400, body: errorBody("BAD_REQUEST", "selector.scope must be an object.") };
+    }
+    if (!validateMemoryScope(raw).ok) {
+        return {
+            status: 400,
+            body: errorBody("BAD_REQUEST", "selector.scope must be a valid memory scope."),
+        };
+    }
+    return raw;
+}
 // ─── Body reading ──────────────────────────────────────────────────────────────
 class BodyTooLargeError extends Error {
     constructor() {
@@ -185,6 +198,26 @@ function listMemoriesAcrossScopes(vault, options) {
     });
     return sortMemories(filtered);
 }
+function isStaleReviewCandidate(record) {
+    return (record.staleReason !== undefined &&
+        record.status !== "proposed" &&
+        record.status !== "conflicted" &&
+        record.status !== "expired" &&
+        record.status !== "rejected" &&
+        record.status !== "archived" &&
+        record.status !== "forgotten");
+}
+function listReviewQueueMemories(vault) {
+    const byStatus = listMemoriesAcrossScopes(vault, {
+        statuses: REVIEW_QUEUE_STATUSES,
+    });
+    const stale = listMemoriesAcrossScopes(vault, {}).filter(isStaleReviewCandidate);
+    const byId = new Map();
+    for (const record of [...byStatus, ...stale]) {
+        byId.set(record.id, record);
+    }
+    return sortMemories([...byId.values()]);
+}
 function parseListParams(ctx) {
     const scopeKinds = splitComma(ctx.url.searchParams.get("scope"));
     const types = splitComma(ctx.url.searchParams.get("type"));
@@ -259,9 +292,7 @@ export function handleMemoryReviewQueue(_ctx, deps) {
     if (isRouteResult(vault))
         return vault;
     try {
-        const proposed = listMemoriesAcrossScopes(vault, {
-            statuses: REVIEW_QUEUE_STATUSES,
-        });
+        const proposed = listReviewQueueMemories(vault);
         return {
             status: 200,
             body: {
@@ -466,7 +497,7 @@ export async function handleArchiveMemory(ctx, deps) {
         throw err;
     }
 }
-function parseForgetInput(raw) {
+function parseDestructiveInput(raw, defaultReason) {
     if (raw.acknowledged !== true) {
         return {
             status: 400,
@@ -475,30 +506,152 @@ function parseForgetInput(raw) {
     }
     const reason = typeof raw.reason === "string" && raw.reason.trim().length > 0
         ? raw.reason.trim()
-        : "user-initiated forget from Memory Center";
+        : defaultReason;
     return { reason };
 }
-function executeForget(vault, id, reason) {
-    const record = vault.getMemory(id);
-    if (record === undefined) {
-        return { status: 404, body: errorBody("NOT_FOUND", "Memory not found.") };
+function parseByIdForgetSelector(raw) {
+    if (typeof raw.memoryId !== "string" || raw.memoryId.trim().length === 0) {
+        return {
+            status: 400,
+            body: errorBody("BAD_REQUEST", "selector.memoryId must be a non-empty string."),
+        };
+    }
+    return { kind: "by-id", memoryId: raw.memoryId };
+}
+function parseByScopeForgetSelector(raw) {
+    const scope = parseScope(raw.scope);
+    if (isRouteResult(scope))
+        return scope;
+    return { kind: "by-scope", scope };
+}
+function parseByTypeForgetSelector(raw) {
+    const scope = parseScope(raw.scope);
+    if (isRouteResult(scope))
+        return scope;
+    if (!isMemoryType(raw.type)) {
+        return {
+            status: 400,
+            body: errorBody("BAD_REQUEST", "selector.type must be a valid memory type."),
+        };
+    }
+    return { kind: "by-type", scope, type: raw.type };
+}
+function parseBySourceConversationForgetSelector(raw) {
+    const scope = parseScope(raw.scope);
+    if (isRouteResult(scope))
+        return scope;
+    if (typeof raw.sourceConversationId !== "string" ||
+        raw.sourceConversationId.trim().length === 0) {
+        return {
+            status: 400,
+            body: errorBody("BAD_REQUEST", "selector.sourceConversationId must be a non-empty string."),
+        };
     }
+    return {
+        kind: "by-source-conversation",
+        scope,
+        sourceConversationId: raw.sourceConversationId,
+    };
+}
+function parseByTimeWindowForgetSelector(raw) {
+    const scope = parseScope(raw.scope);
+    if (isRouteResult(scope))
+        return scope;
+    if (typeof raw.olderThanMs !== "number" ||
+        !Number.isFinite(raw.olderThanMs) ||
+        raw.olderThanMs < 0) {
+        return {
+            status: 400,
+            body: errorBody("BAD_REQUEST", "selector.olderThanMs must be a finite non-negative number."),
+        };
+    }
+    return { kind: "by-time-window", scope, olderThanMs: raw.olderThanMs };
+}
+function parseForgetSelector(raw) {
+    if (!isRecord(raw)) {
+        return { status: 400, body: errorBody("BAD_REQUEST", "selector must be an object.") };
+    }
+    switch (raw.kind) {
+        case "by-id":
+            return parseByIdForgetSelector(raw);
+        case "by-scope":
+            return parseByScopeForgetSelector(raw);
+        case "by-type":
+            return parseByTypeForgetSelector(raw);
+        case "by-source-conversation":
+            return parseBySourceConversationForgetSelector(raw);
+        case "by-time-window":
+            return parseByTimeWindowForgetSelector(raw);
+        default:
+            return {
+                status: 400,
+                body: errorBody("BAD_REQUEST", "selector.kind is not supported."),
+            };
+    }
+}
+function parseForgetSelectionInput(raw) {
+    const destructive = parseDestructiveInput(raw, "user-initiated selective forget from MemoriaViva");
+    if (isRouteResult(destructive))
+        return destructive;
+    const selector = parseForgetSelector(raw.selector);
+    if (isRouteResult(selector))
+        return selector;
+    return { ...destructive, selector };
+}
+function listForgetCandidates(vault, selector) {
+    if (selector.kind === "by-id") {
+        const record = vault.getMemory(selector.memoryId);
+        if (record === undefined) {
+            return { status: 404, body: errorBody("NOT_FOUND", "Memory not found.") };
+        }
+        return [record];
+    }
+    return sortMemories(vault.listMemoriesByScope(selector.scope, { includeExpired: true }));
+}
+function executeForgetSelection(vault, selector, reason) {
     const nowMs = Date.now();
-    const candidates = selectMemoriesForForget([record], { kind: "by-id", memoryId: id }, { nowMs });
+    const records = listForgetCandidates(vault, selector);
+    if (isRouteResult(records))
+        return records;
+    const candidates = selectMemoriesForForget(records, selector, { nowMs });
     if (candidates.length === 0) {
         return {
             status: 409,
-            body: errorBody("GOVERNANCE_ERROR", "Memory cannot be forgotten (it may be pinned)."),
+            body: errorBody("GOVERNANCE_ERROR", "No matching memories can be forgotten."),
         };
     }
-    buildForgetOperations(candidates, { reviewerId: DEFAULT_REVIEWER_ID, nowMs }, { reason, writeTombstone: true });
-    vault.deleteMemory(id, {
-        tombstone: true,
-        reason,
-        forgetterSurface: "memory-center",
-        nowMs,
-    });
-    return { status: 200, body: { forgotten: true, memoryId: id } };
+    const operations = buildForgetOperations(candidates, { reviewerId: DEFAULT_REVIEWER_ID, nowMs }, { reason, writeTombstone: true });
+    vault.deleteMemories(operations.map((operation) => ({
+        id: operation.memoryId,
+        options: {
+            tombstone: true,
+            reviewerId: operation.reviewerId,
+            reason: operation.reason,
+            forgetterSurface: "memory-center",
+            nowMs: operation.forgottenAt,
+        },
+    })));
+    return { memoryIds: operations.map((operation) => operation.memoryId) };
+}
+function formatForgetBody(memoryIds) {
+    return {
+        forgotten: true,
+        memoryIds,
+        count: memoryIds.length,
+        ...(memoryIds.length === 1 ? { memoryId: memoryIds[0] } : {}),
+    };
+}
+function memoryMutationErrorBody(err, fallbackMessage) {
+    if (err instanceof GovernanceError) {
+        return { status: 400, body: governanceErrorBody(err) };
+    }
+    if (err instanceof MemoryStorageError) {
+        return {
+            status: err.code === "not-found" ? 404 : 500,
+            body: errorBody("MEMORY_ERROR", fallbackMessage),
+        };
+    }
+    throw err;
 }
 export async function handleForgetMemory(ctx, deps) {
     const vault = resolveVault(deps);
@@ -511,28 +664,42 @@ export async function handleForgetMemory(ctx, deps) {
     const body = await readJsonBody(ctx.req);
     if (isRouteResult(body))
         return body;
-    const input = parseForgetInput(body);
+    const input = parseDestructiveInput(body, "user-initiated forget from MemoriaViva");
     if (isRouteResult(input))
         return input;
     try {
-        return executeForget(vault, id, input.reason);
+        const result = executeForgetSelection(vault, { kind: "by-id", memoryId: id }, input.reason);
+        if (isRouteResult(result))
+            return result;
+        return { status: 200, body: formatForgetBody(result.memoryIds) };
     }
     catch (err) {
-        if (err instanceof GovernanceError) {
-            return { status: 400, body: governanceErrorBody(err) };
-        }
-        if (err instanceof MemoryStorageError) {
-            return {
-                status: err.code === "not-found" ? 404 : 500,
-                body: errorBody("MEMORY_ERROR", "Failed to forget memory."),
-            };
-        }
-        throw err;
+        return memoryMutationErrorBody(err, "Failed to forget memory.");
+    }
+}
+export async function handleForgetMemories(ctx, deps) {
+    const vault = resolveVault(deps);
+    if (isRouteResult(vault))
+        return vault;
+    const body = await readJsonBody(ctx.req);
+    if (isRouteResult(body))
+        return body;
+    const input = parseForgetSelectionInput(body);
+    if (isRouteResult(input))
+        return input;
+    try {
+        const result = executeForgetSelection(vault, input.selector, input.reason);
+        if (isRouteResult(result))
+            return result;
+        return { status: 200, body: formatForgetBody(result.memoryIds) };
+    }
+    catch (err) {
+        return memoryMutationErrorBody(err, "Failed to forget memories.");
     }
 }
 // ─── Handler: DELETE /api/memory/:id ──────────────────────────────────────────
-// Hard delete without a tombstone. Intended for admin / data cleanup.
-export function handleDeleteMemory(ctx, deps) {
+// DELETE is a convenience alias for governed, tombstoned deletion. It does not expose hard delete.
+export async function handleDeleteMemory(ctx, deps) {
     const vault = resolveVault(deps);
     if (isRouteResult(vault))
         return vault;
@@ -540,26 +707,176 @@ export function handleDeleteMemory(ctx, deps) {
     if (id === undefined || id.length === 0) {
         return { status: 400, body: errorBody("BAD_REQUEST", "Memory id is required.") };
     }
+    const body = await readJsonBody(ctx.req);
+    if (isRouteResult(body))
+        return body;
+    const input = parseDestructiveInput(body, "user-initiated delete from MemoriaViva");
+    if (isRouteResult(input))
+        return input;
     try {
-        const existing = vault.getMemory(id);
-        if (existing === undefined) {
+        const result = executeForgetSelection(vault, { kind: "by-id", memoryId: id }, input.reason);
+        if (isRouteResult(result))
+            return result;
+        return {
+            status: 200,
+            body: {
+                deleted: true,
+                memoryId: id,
+                memoryIds: result.memoryIds,
+                count: result.memoryIds.length,
+            },
+        };
+    }
+    catch (err) {
+        return memoryMutationErrorBody(err, "Failed to delete memory.");
+    }
+}
+function uniqueIds(ids) {
+    return ids.filter((id, index) => ids.indexOf(id) === index);
+}
+function parseConflictResolutionInput(raw) {
+    if (typeof raw.winner !== "string" || raw.winner.trim().length === 0) {
+        return { status: 400, body: errorBody("BAD_REQUEST", "winner must be a non-empty string.") };
+    }
+    if (!Array.isArray(raw.losers) ||
+        raw.losers.length === 0 ||
+        !raw.losers.every((id) => typeof id === "string" && id.trim().length > 0)) {
+        return {
+            status: 400,
+            body: errorBody("BAD_REQUEST", "losers must be a non-empty string array."),
+        };
+    }
+    const reason = typeof raw.reason === "string" && raw.reason.trim().length > 0
+        ? raw.reason.trim()
+        : "conflict resolved from MemoriaViva";
+    const winner = raw.winner;
+    const losers = raw.losers.map((id) => id);
+    if (uniqueIds([winner, ...losers]).length !== 1 + losers.length) {
+        return {
+            status: 400,
+            body: errorBody("BAD_REQUEST", "winner and losers must be unique memory ids."),
+        };
+    }
+    return {
+        winner,
+        losers,
+        reason,
+    };
+}
+function loadConflictMemories(vault, input) {
+    const records = [];
+    for (const id of uniqueIds([input.winner, ...input.losers])) {
+        const record = vault.getMemory(id);
+        if (record === undefined) {
             return { status: 404, body: errorBody("NOT_FOUND", "Memory not found.") };
         }
-        vault.deleteMemory(id, {
-            tombstone: false,
-            forgetterSurface: "memory-center",
-            nowMs: Date.now(),
-        });
-        return { status: 200, body: { deleted: true, memoryId: id } };
+        records.push(record);
     }
-    catch (err) {
-        if (err instanceof MemoryStorageError) {
-            return {
-                status: err.code === "not-found" ? 404 : 500,
-                body: errorBody("MEMORY_ERROR", "Failed to delete memory."),
-            };
+    return records;
+}
+function scopeKey(scope) {
+    switch (scope.kind) {
+        case "user":
+            return `user:${scope.userId}`;
+        case "workspace":
+            return `workspace:${scope.workspaceId}`;
+        case "project":
+            return `project:${scope.projectId}`;
+        case "workflow":
+            return `workflow:${scope.workflowDefinitionId}`;
+        case "global":
+            return "global";
+    }
+}
+function validateConflictPairForResolution(winner, loser) {
+    if (winner.type !== loser.type || scopeKey(winner.scope) !== scopeKey(loser.scope)) {
+        throw new GovernanceError("invalid-resolution", "conflict resolution requires memories with the same scope and type");
+    }
+    const conflict = detectConflictPair(winner, loser);
+    if (!conflict.hasConflict) {
+        throw new GovernanceError("invalid-resolution", "conflict resolution requires an actual detected conflict");
+    }
+}
+function validateConflictResolutionMemories(memories, input) {
+    const winner = findMemoryById(memories, input.winner);
+    if (winner === undefined) {
+        throw new GovernanceError("invalid-resolution", "winner is not loaded");
+    }
+    for (const loserId of input.losers) {
+        const loser = findMemoryById(memories, loserId);
+        if (loser === undefined) {
+            throw new GovernanceError("invalid-resolution", "loser is not loaded");
         }
-        throw err;
+        validateConflictPairForResolution(winner, loser);
+    }
+}
+function buildEdgeFromSupersession(supersession) {
+    return {
+        id: randomUUID(),
+        schemaVersion: "1",
+        fromMemoryId: supersession.oldMemoryId,
+        toMemoryId: supersession.newMemoryId,
+        kind: supersession.edgeKind,
+        createdAt: supersession.supersededAt,
+        provenanceSummary: supersession.reason,
+    };
+}
+function findMemoryById(memories, id) {
+    return memories.find((memory) => memory.id === id);
+}
+function persistConflictTransitions(vault, resolution, reason) {
+    for (const transition of resolution.statusTransitions) {
+        vault.updateMemory(transition.memoryId, { status: transition.to, staleReason: reason }, transition.transitionedAt);
+    }
+}
+function persistConflictSupersessions(vault, deps, memories, supersessions, nowMs) {
+    const edgeIds = [];
+    for (const supersession of supersessions) {
+        const edge = vault.insertEdge(buildEdgeFromSupersession(supersession));
+        edgeIds.push(edge.id);
+        const loser = findMemoryById(memories, supersession.oldMemoryId);
+        const winner = findMemoryById(memories, supersession.newMemoryId);
+        if (loser === undefined || winner === undefined)
+            continue;
+        recordSupersessionAudit(deps, loser, winner, nowMs, "Conflict resolution linked losing memory to the selected winner.");
+    }
+    return edgeIds;
+}
+function executeConflictResolution(vault, deps, input) {
+    const memories = loadConflictMemories(vault, input);
+    if (isRouteResult(memories))
+        return memories;
+    validateConflictResolutionMemories(memories, input);
+    const nowMs = Date.now();
+    const resolution = buildConflictTransitions(memories, { winner: input.winner, losers: input.losers }, { reviewerId: DEFAULT_REVIEWER_ID, nowMs });
+    persistConflictTransitions(vault, resolution, input.reason);
+    const edgeIds = persistConflictSupersessions(vault, deps, memories, resolution.supersessions, nowMs);
+    return {
+        resolved: true,
+        winner: input.winner,
+        losers: input.losers,
+        supersessionEdgeIds: edgeIds,
+        transitions: resolution.statusTransitions,
+    };
+}
+export async function handleResolveMemoryConflict(ctx, deps) {
+    const vault = resolveVault(deps);
+    if (isRouteResult(vault))
+        return vault;
+    const body = await readJsonBody(ctx.req);
+    if (isRouteResult(body))
+        return body;
+    const input = parseConflictResolutionInput(body);
+    if (isRouteResult(input))
+        return input;
+    try {
+        const result = executeConflictResolution(vault, deps, input);
+        if (isRouteResult(result))
+            return result;
+        return { status: 200, body: result };
+    }
+    catch (err) {
+        return memoryMutationErrorBody(err, "Failed to resolve conflict.");
     }
 }
 // ─── Handler: POST /api/memory/:id/correct ────────────────────────────────────
@@ -574,26 +891,74 @@ function parseCorrectInput(raw) {
     }
     return { correctedBody };
 }
-function buildCorrectionRecord(existing, correctedBody, nowMs) {
+function buildCorrectionRecord(proposal, id, nowMs) {
     // Note: exactOptionalPropertyTypes is on — omit staleReason rather than assigning undefined.
-    return {
-        id: randomUUID(),
+    const base = {
+        id,
         schemaVersion: "1",
-        scope: existing.scope,
-        type: "correction",
-        body: correctedBody,
-        provenance: {
-            ...existing.provenance,
-            sourceKind: "accepted-correction",
-            capturedAt: nowMs,
-        },
-        validity: existing.validity,
-        status: "proposed",
+        scope: proposal.scope,
+        type: proposal.type,
+        body: proposal.body,
+        provenance: proposal.provenance,
+        validity: proposal.validity,
+        status: proposal.initialStatus,
         pinned: false,
-        tags: existing.tags,
+        tags: proposal.tags,
         createdAt: nowMs,
         updatedAt: nowMs,
     };
+    return {
+        ...base,
+        ...(proposal.payload === undefined ? {} : { payload: proposal.payload }),
+        ...(proposal.retentionHint === undefined ? {} : { retentionHint: proposal.retentionHint }),
+    };
+}
+function redactString(deps, value) {
+    const redacted = deps.redactor(value);
+    return typeof redacted === "string" ? redacted : value;
+}
+function recordSupersessionAudit(deps, oldMemory, newMemory, nowMs, summary) {
+    const event = {
+        schemaVersion: "1",
+        kind: "memory:superseded",
+        eventId: randomUUID(),
+        occurredAt: nowMs,
+        initiatorSurface: "memory-center",
+        summary,
+        oldMemoryId: oldMemory.id,
+        newMemoryId: newMemory.id,
+        scope: oldMemory.scope,
+    };
+    recordMemoryAudit({ evidenceStore: deps.evidenceStore, redactString: (value) => redactString(deps, value) }, event);
+}
+function auditEventCountForDay(deps, nowMs) {
+    const json = deps.evidenceStore.get(auditRunIdFor(nowMs));
+    if (json === undefined) {
+        return 0;
+    }
+    try {
+        const parsed = JSON.parse(json);
+        return Array.isArray(parsed) ? parsed.length : 0;
+    }
+    catch {
+        return 0;
+    }
+}
+function recordCorrectionProposalAuditIfNeeded(deps, inserted, nowMs, countBeforeInsert) {
+    if (auditEventCountForDay(deps, nowMs) > countBeforeInsert) {
+        return;
+    }
+    const event = {
+        schemaVersion: "1",
+        kind: "memory:proposed",
+        eventId: randomUUID(),
+        occurredAt: nowMs,
+        initiatorSurface: "memory-center",
+        summary: `memory ${inserted.id} correction proposed`,
+        memoryId: inserted.id,
+        scope: inserted.scope,
+    };
+    recordMemoryAudit({ evidenceStore: deps.evidenceStore, redactString: (value) => redactString(deps, value) }, event);
 }
 export async function handleCorrectMemory(ctx, deps) {
     const vault = resolveVault(deps);
@@ -614,13 +979,28 @@ export async function handleCorrectMemory(ctx, deps) {
         if (existing === undefined) {
             return { status: 404, body: errorBody("NOT_FOUND", "Memory not found.") };
         }
-        const inserted = vault.insertMemory(buildCorrectionRecord(existing, input.correctedBody, Date.now()));
+        const nowMs = Date.now();
+        const correctionId = randomUUID();
+        const { proposal, supersession } = buildCorrection({
+            olderMemory: existing,
+            correctedBody: input.correctedBody,
+            context: { reviewerId: DEFAULT_REVIEWER_ID, nowMs },
+            newProposalId: randomUUID(),
+            newMemoryId: correctionId,
+        });
+        const auditCountBeforeInsert = auditEventCountForDay(deps, nowMs);
+        const inserted = vault.insertMemory(buildCorrectionRecord(proposal, correctionId, nowMs));
+        recordCorrectionProposalAuditIfNeeded(deps, inserted, nowMs, auditCountBeforeInsert);
+        vault.insertEdge(buildEdgeFromSupersession(supersession));
         return {
             status: 201,
             body: { correction: redactMemory(deps, inserted), originalMemoryId: id },
         };
     }
     catch (err) {
+        if (err instanceof GovernanceError) {
+            return { status: 400, body: governanceErrorBody(err) };
+        }
         if (err instanceof MemoryStorageError) {
             return { status: 500, body: errorBody("MEMORY_ERROR", "Failed to create correction.") };
         }
@@ -628,6 +1008,94 @@ export async function handleCorrectMemory(ctx, deps) {
     }
 }
 // ─── Handler: POST /api/memory/proposals/:id/accept ───────────────────────────
+function assertSupersedable(memory) {
+    const check = checkStatusTransition(memory.status, "superseded");
+    if (!check.ok) {
+        throw new GovernanceError("illegal-status-transition", check.reason ?? `illegal transition: ${memory.status} -> superseded`);
+    }
+}
+function loadCorrectionSupersessionOrigins(vault, proposal) {
+    if (proposal.type !== "correction")
+        return [];
+    const incomingSupersessions = vault
+        .listIncomingEdges(proposal.id)
+        .filter((edge) => edge.kind === "supersedes");
+    if (incomingSupersessions.length === 0) {
+        throw new GovernanceError("invalid-resolution", "correction proposal requires a supersession origin");
+    }
+    return incomingSupersessions.map((edge) => {
+        const original = vault.getMemory(edge.fromMemoryId);
+        if (original === undefined) {
+            throw new GovernanceError("invalid-resolution", "correction origin memory is missing");
+        }
+        return { edge, original };
+    });
+}
+function acceptedCorrectionType(origins) {
+    if (origins.length === 0)
+        return undefined;
+    const first = origins[0]?.original.type;
+    if (first === undefined)
+        return undefined;
+    for (const origin of origins) {
+        if (origin.original.type !== first) {
+            throw new GovernanceError("invalid-resolution", "correction origins must have the same memory type");
+        }
+        assertSupersedable(origin.original);
+    }
+    return first;
+}
+function buildAcceptProposalPatch(origins) {
+    const correctionType = acceptedCorrectionType(origins);
+    return correctionType === undefined
+        ? { status: "accepted" }
+        : { status: "accepted", type: correctionType };
+}
+function buildCorrectionAcceptanceUpdates(proposalId, acceptPatch, origins, nowMs) {
+    return [
+        { id: proposalId, patch: acceptPatch, nowMs },
+        ...origins.map(({ edge, original }) => ({
+            id: original.id,
+            patch: {
+                status: "superseded",
+                staleReason: edge.provenanceSummary ?? "accepted correction",
+            },
+            nowMs,
+        })),
+    ];
+}
+function recordCorrectionSupersessionAudits(deps, acceptedCorrection, origins, nowMs) {
+    for (const { original } of origins) {
+        recordSupersessionAudit(deps, original, acceptedCorrection, nowMs, "Accepted correction superseded the original memory.");
+    }
+}
+function ensureProposedMemory(existing) {
+    if (existing === undefined) {
+        return { status: 404, body: errorBody("NOT_FOUND", "Memory proposal not found.") };
+    }
+    if (existing.status !== "proposed") {
+        return {
+            status: 409,
+            body: errorBody("CONFLICT", "Memory is not in proposed status."),
+        };
+    }
+    return existing;
+}
+function acceptMemoryProposal(vault, deps, id) {
+    const existing = ensureProposedMemory(vault.getMemory(id));
+    if (isRouteResult(existing))
+        return existing;
+    const nowMs = Date.now();
+    const origins = loadCorrectionSupersessionOrigins(vault, existing);
+    const acceptPatch = buildAcceptProposalPatch(origins);
+    const updates = buildCorrectionAcceptanceUpdates(id, acceptPatch, origins, nowMs);
+    const [updated] = vault.updateMemories(updates);
+    if (updated === undefined) {
+        throw new GovernanceError("invalid-resolution", "acceptance update produced no records");
+    }
+    recordCorrectionSupersessionAudits(deps, updated, origins, nowMs);
+    return { status: 200, body: { memory: redactMemory(deps, updated) } };
+}
 export function handleAcceptMemoryProposal(ctx, deps) {
     const vault = resolveVault(deps);
     if (isRouteResult(vault))
@@ -637,27 +1105,10 @@ export function handleAcceptMemoryProposal(ctx, deps) {
         return { status: 400, body: errorBody("BAD_REQUEST", "Memory id is required.") };
     }
     try {
-        const existing = vault.getMemory(id);
-        if (existing === undefined) {
-            return { status: 404, body: errorBody("NOT_FOUND", "Memory proposal not found.") };
-        }
-        if (existing.status !== "proposed") {
-            return {
-                status: 409,
-                body: errorBody("CONFLICT", "Memory is not in proposed status."),
-            };
-        }
-        const updated = vault.updateMemory(id, { status: "accepted" }, Date.now());
-        return { status: 200, body: { memory: redactMemory(deps, updated) } };
+        return acceptMemoryProposal(vault, deps, id);
     }
     catch (err) {
-        if (err instanceof MemoryStorageError) {
-            return {
-                status: err.code === "not-found" ? 404 : 500,
-                body: errorBody("MEMORY_ERROR", "Failed to accept proposal."),
-            };
-        }
-        throw err;
+        return memoryMutationErrorBody(err, "Failed to accept proposal.");
     }
 }
 // ─── Handler: POST /api/memory/proposals/:id/reject ───────────────────────────