@jungjaehoon/mama-core 4.1.0 → 5.0.0

package/dist/memory/decision-links.d.ts

@@ -0,0 +1,54 @@
+import type { DatabaseAdapter } from '../db-manager.js';
+import { type LinkReceipt } from '../knowledge/links.js';
+import type { RecordLink } from './judgment-types.js';
+/**
+ * Decision links for the direct memory API (the Claude Code MCP): one decision linked to another,
+ * or to a link it corrects, with the reason the caller judged. Nothing is edited.
+ */
+export interface DecisionLinkInput {
+    from: string;
+    /** A decision id, or the id of a link this one contradicts. */
+    to: string;
+    relation: RecordLink['relation'];
+    reason: string;
+}
+export declare function appendDecisionLink(adapter: Pick<DatabaseAdapter, 'prepare' | 'transaction' | 'transactionImmediate'>, input: DecisionLinkInput): LinkReceipt;
+export interface DecisionEdgeView {
+    relation: string;
+    direction: 'out' | 'in';
+    otherId: string;
+    otherTopic: string | null;
+    otherSummary: string | null;
+    reason: string | null;
+    /** agent: stated through a link; agent_text: parsed from reasoning text; host: written by code. */
+    source: 'agent' | 'agent_text' | 'host' | 'user';
+    edgeId?: string;
+    correctedBy?: DecisionCorrection[];
+    /** On an incoming amends edge: the values the amending record replaced on this decision. */
+    replacedValues?: Record<string, unknown>;
+}
+export interface DecisionCorrection {
+    edgeId: string;
+    /** The record that states the correction. */
+    from: string;
+    reason: string | null;
+    at: number;
+    correctedBy?: DecisionCorrection[];
+}
+export interface DecisionWithEdges {
+    id: string;
+    topic: string;
+    decision: string;
+    reasoning: string | null;
+    outcome: string | null;
+    status: string | null;
+    createdAt: number;
+    supersedes: string | null;
+    supersededBy: string | null;
+    edges: DecisionEdgeView[];
+}
+/** Links that contradict these edges, and the links that contradict those, in two queries per level. */
+export declare function correctionsOf(adapter: Pick<DatabaseAdapter, 'prepare'>, edgeIds: readonly string[]): Map<string, DecisionCorrection[]>;
+/** One decision with every edge in and out, each with its reason and who wrote it. */
+export declare function readDecisionWithEdges(adapter: Pick<DatabaseAdapter, 'prepare'>, id: string): DecisionWithEdges | null;
+//# sourceMappingURL=decision-links.d.ts.map

package/dist/memory/decision-links.js

@@ -0,0 +1,195 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.appendDecisionLink = appendDecisionLink;
+exports.correctionsOf = correctionsOf;
+exports.readDecisionWithEdges = readDecisionWithEdges;
+const node_crypto_1 = __importDefault(require("node:crypto"));
+const canonicalize_js_1 = require("../canonicalize.js");
+const graph_query_js_1 = require("../knowledge/graph-query.js");
+const links_js_1 = require("../knowledge/links.js");
+const secret_filter_js_1 = require("./secret-filter.js");
+const write_adapters_js_1 = require("./write-adapters.js");
+function isEdgeId(id) {
+    return id.startsWith('link_') || id.startsWith('edge_');
+}
+function appendDecisionLink(adapter, input) {
+    // The reason is stored text, like a checkpoint's, so it passes the same secret scan.
+    const scan = (0, secret_filter_js_1.scanMemoryWriteInput)({ reason: input.reason });
+    if (!scan.clean)
+        throw new secret_filter_js_1.SecretMaterialRefusedError(scan.matches);
+    const to = isEdgeId(input.to)
+        ? { kind: 'edge', id: input.to }
+        : { kind: 'memory', id: input.to };
+    const scopes = new Map();
+    const memoryEnds = [input.from, ...(to.kind === 'memory' ? [to.id] : [])];
+    // A correction reads the corrected link, so its ends must be admitted too, down the chain when
+    // it corrects a correction. A link names only an edge that already exists, so the chain ends.
+    const endsOf = adapter.prepare(`SELECT subject_kind, subject_id, object_kind, object_id FROM twin_edges WHERE edge_id = ?`);
+    let edgeIds = to.kind === 'edge' ? [to.id] : [];
+    while (edgeIds.length > 0) {
+        const next = [];
+        for (const edgeId of edgeIds) {
+            const ends = endsOf.get(edgeId);
+            // An unknown edge is refused by appendLink, which names the caller's own id.
+            if (!ends)
+                continue;
+            for (const [kind, id] of [
+                [ends.subject_kind, ends.subject_id],
+                [ends.object_kind, ends.object_id],
+            ]) {
+                if (kind === 'memory')
+                    memoryEnds.push(id);
+                else if (kind === 'edge')
+                    next.push(id);
+            }
+        }
+        edgeIds = next;
+    }
+    for (const scope of memoryEnds.flatMap((id) => (0, write_adapters_js_1.boundScopesOf)(adapter, id))) {
+        scopes.set(`${scope.kind}\0${scope.id}`, scope);
+    }
+    // The same statement retried is the same link; a different reason is a different statement.
+    const commandId = `link:${node_crypto_1.default
+        .createHash('sha256')
+        .update((0, canonicalize_js_1.canonicalizeJSON)(input))
+        .digest('hex')
+        .slice(0, 24)}`;
+    return (0, links_js_1.appendLink)(adapter, {
+        commandId,
+        from: { kind: 'memory', id: input.from },
+        to,
+        relation: input.relation,
+        reason: input.reason,
+    }, (0, write_adapters_js_1.unsignedWriteAccess)([...scopes.values()]));
+}
+function legacySource(reason, createdBy) {
+    if (reason && graph_query_js_1.HOST_EDGE_REASON_PREFIXES.some((prefix) => reason.startsWith(prefix)))
+        return 'host';
+    if (createdBy === 'llm' || reason?.startsWith('Auto-detected from reasoning'))
+        return 'agent_text';
+    return 'user';
+}
+/** Links that contradict these edges, and the links that contradict those, in two queries per level. */
+function correctionsOf(adapter, edgeIds) {
+    const byTarget = new Map();
+    let frontier = [...edgeIds];
+    while (frontier.length > 0) {
+        const placeholders = frontier.map(() => '?').join(', ');
+        const rows = adapter
+            .prepare(`SELECT edge_id, subject_id, object_id, reason_text, created_at FROM twin_edges
+          WHERE object_kind = 'edge' AND edge_type = 'contradicts' AND object_id IN (${placeholders})
+          ORDER BY created_at, rowid`)
+            .all(...frontier);
+        for (const row of rows) {
+            const list = byTarget.get(row.object_id) ?? [];
+            list.push({
+                edgeId: row.edge_id,
+                from: row.subject_id,
+                reason: row.reason_text,
+                at: row.created_at,
+            });
+            byTarget.set(row.object_id, list);
+        }
+        // A link names only an edge that already exists, so the chain has no cycle.
+        frontier = rows.map((row) => row.edge_id);
+    }
+    const nest = (edgeId) => byTarget.get(edgeId)?.map((correction) => {
+        const further = nest(correction.edgeId);
+        return further ? { ...correction, correctedBy: further } : correction;
+    });
+    const nested = new Map();
+    for (const edgeId of edgeIds) {
+        const list = nest(edgeId);
+        if (list)
+            nested.set(edgeId, list);
+    }
+    return nested;
+}
+function replacedValuesFor(payloadOf, amendingId, targetId) {
+    const row = payloadOf.get(amendingId);
+    if (!row?.payload_json)
+        return undefined;
+    const payload = JSON.parse(row.payload_json);
+    return payload.replacedValues?.find((entry) => entry.target === targetId)?.values;
+}
+/** One decision with every edge in and out, each with its reason and who wrote it. */
+function readDecisionWithEdges(adapter, id) {
+    const row = adapter
+        .prepare(`SELECT id, topic, decision, reasoning, outcome, status, created_at, supersedes, superseded_by
+         FROM decisions WHERE id = ?`)
+        .get(id);
+    if (!row)
+        return null;
+    const other = adapter.prepare('SELECT topic, decision FROM decisions WHERE id = ?');
+    const describe = (otherId) => {
+        const found = other.get(otherId);
+        return {
+            otherTopic: found?.topic ?? null,
+            otherSummary: found ? found.decision.split('\n')[0].slice(0, 200) : null,
+        };
+    };
+    const edges = [];
+    const twin = adapter
+        .prepare(`SELECT edge_id, edge_type, subject_id, object_id, reason_text, relation_attrs_json, source
+         FROM twin_edges
+        WHERE edge_type <> 'derived_from'
+          AND ((subject_kind = 'memory' AND subject_id = ? AND object_kind = 'memory')
+            OR (object_kind = 'memory' AND object_id = ? AND subject_kind = 'memory'))
+        ORDER BY created_at, rowid`)
+        .all(id, id);
+    const corrections = correctionsOf(adapter, twin.map((edge) => edge.edge_id));
+    const payloadOf = adapter.prepare('SELECT payload_json FROM decisions WHERE id = ?');
+    for (const edge of twin) {
+        const out = edge.subject_id === id;
+        const otherId = out ? edge.object_id : edge.subject_id;
+        const attrs = edge.relation_attrs_json
+            ? JSON.parse(edge.relation_attrs_json)
+            : {};
+        const corrected = corrections.get(edge.edge_id);
+        const replaced = !out && edge.edge_type === 'amends' ? replacedValuesFor(payloadOf, otherId, id) : undefined;
+        edges.push({
+            relation: edge.edge_type,
+            direction: out ? 'out' : 'in',
+            otherId,
+            ...describe(otherId),
+            reason: typeof attrs.reason === 'string' ? attrs.reason : edge.reason_text,
+            source: edge.source === 'code' ? 'host' : 'agent',
+            edgeId: edge.edge_id,
+            ...(corrected ? { correctedBy: corrected } : {}),
+            ...(replaced ? { replacedValues: replaced } : {}),
+        });
+    }
+    const legacy = adapter
+        .prepare(`SELECT from_id, to_id, relationship, reason, created_by FROM decision_edges
+        WHERE from_id = ? OR to_id = ?
+        ORDER BY created_at`)
+        .all(id, id);
+    for (const edge of legacy) {
+        const out = edge.from_id === id;
+        const otherId = out ? edge.to_id : edge.from_id;
+        edges.push({
+            relation: edge.relationship,
+            direction: out ? 'out' : 'in',
+            otherId,
+            ...describe(otherId),
+            reason: edge.reason,
+            source: legacySource(edge.reason, edge.created_by),
+        });
+    }
+    return {
+        id: row.id,
+        topic: row.topic,
+        decision: row.decision,
+        reasoning: row.reasoning,
+        outcome: row.outcome,
+        status: row.status,
+        createdAt: row.created_at,
+        supersedes: row.supersedes,
+        supersededBy: row.superseded_by,
+        edges,
+    };
+}
+//# sourceMappingURL=decision-links.js.map

package/dist/memory/graph-read.d.ts

@@ -23,9 +23,6 @@ export interface GraphReadEdge {
     relationship: string;
     reason: string | null;
 }
-export interface GraphSimilarityEdge extends GraphReadEdge {
-    similarity: number;
-}
 export interface GraphScope {
     kind: string;
     id: string;
@@ -36,17 +33,4 @@ export declare function readGraphNodes(adapter: DatabaseAdapter, scopes: readonl
 }): Promise<GraphReadNode[]>;
 export declare function readGraphEdges(adapter: DatabaseAdapter, scopes: readonly GraphScope[]): Promise<GraphReadEdge[]>;
 export declare function countGraphNodes(adapter: DatabaseAdapter, scopes: readonly GraphScope[]): Promise<number>;
-/**
- * Similarity edges over the admitted set.
- *
- * This embeds a bounded window of admitted nodes and asks the vector index what
- * each is near. It lives here rather than in an HTTP handler because that is
- * where the embedder is — a door that embeds is a door that has opinions about
- * what memory means.
- */
-export declare function readGraphSimilarityEdges(adapter: DatabaseAdapter, scopes: readonly GraphScope[], options?: {
-    window?: number;
-    neighbors?: number;
-    threshold?: number;
-}): Promise<GraphSimilarityEdge[]>;
 //# sourceMappingURL=graph-read.d.ts.map

package/dist/memory/graph-read.js

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.readGraphNodes = readGraphNodes;
 exports.readGraphEdges = readGraphEdges;
 exports.countGraphNodes = countGraphNodes;
-exports.readGraphSimilarityEdges = readGraphSimilarityEdges;
 /**
  * The decision graph, as a caller may see it.
  *
@@ -14,8 +13,6 @@ exports.readGraphSimilarityEdges = readGraphSimilarityEdges;
  * A principal that admits nothing sees an empty graph rather than the file.
  */
 const db_manager_js_1 = require("../db-manager.js");
-const embedder_js_1 = require("../embedding/embedder.js");
-const search_js_1 = require("../knowledge/search.js");
 /** The admitted-node clause both a node read and an edge read stand on. */
 async function admittedScopeIds(adapter, scopes) {
     return Promise.all(scopes.map((scope) => (0, db_manager_js_1.ensureMemoryScope)(adapter, scope.kind, scope.id)));
@@ -48,9 +45,18 @@ async function readGraphEdges(adapter, scopes) {
     const placeholders = scopeIds.map(() => '?').join(', ');
     // Both ends must be admitted: an edge to a memory this caller cannot read
     // would disclose that it exists, which is the read the join is here to bound.
+    // Links between memories live in twin_edges; decision_edges holds the rows
+    // written before links moved there.
     const rows = (await adapter
         .prepare(`SELECT e.from_id, e.to_id, e.relationship, e.reason
-       FROM decision_edges e
+       FROM (
+         SELECT from_id, to_id, relationship, reason FROM decision_edges
+         UNION ALL
+         SELECT subject_id, object_id, edge_type,
+                COALESCE(json_extract(relation_attrs_json, '$.reason'), reason_text)
+           FROM twin_edges
+          WHERE subject_kind = 'memory' AND object_kind = 'memory' AND edge_type <> 'derived_from'
+       ) e
        WHERE EXISTS (
                SELECT 1 FROM memory_scope_bindings b
                WHERE b.memory_id = e.from_id AND b.scope_id IN (${placeholders})
@@ -80,51 +86,4 @@ async function countGraphNodes(adapter, scopes) {
         .get(...scopeIds));
     return row?.count ?? 0;
 }
-/**
- * Similarity edges over the admitted set.
- *
- * This embeds a bounded window of admitted nodes and asks the vector index what
- * each is near. It lives here rather than in an HTTP handler because that is
- * where the embedder is — a door that embeds is a door that has opinions about
- * what memory means.
- */
-async function readGraphSimilarityEdges(adapter, scopes, options = {}) {
-    const window = options.window ?? 50;
-    const neighbors = options.neighbors ?? 3;
-    const threshold = options.threshold ?? 0.7;
-    const nodes = await readGraphNodes(adapter, scopes, { limit: Math.max(window * 2, window) });
-    if (nodes.length < 2) {
-        return [];
-    }
-    const admitted = new Set(nodes.map((node) => node.id));
-    const seen = new Set();
-    const edges = [];
-    for (const node of nodes.slice(0, window)) {
-        const embedding = await (0, embedder_js_1.generateEmbedding)(`${node.topic} ${node.decision}`, 'query');
-        const similar = (await (0, search_js_1.vectorSearch)(adapter, embedding, neighbors, threshold));
-        for (const match of similar) {
-            // A neighbour the caller may not read is not an edge it may see.
-            if (match.id === node.id || !admitted.has(match.id)) {
-                continue;
-            }
-            const similarity = match.similarity ?? threshold;
-            if (similarity <= threshold) {
-                continue;
-            }
-            const key = [node.id, match.id].sort().join('|');
-            if (seen.has(key)) {
-                continue;
-            }
-            seen.add(key);
-            edges.push({
-                from: node.id,
-                to: match.id,
-                relationship: 'similar',
-                reason: null,
-                similarity,
-            });
-        }
-    }
-    return edges;
-}
 //# sourceMappingURL=graph-read.js.map

package/dist/memory/judgment-types.d.ts

@@ -87,8 +87,7 @@ export interface JudgmentRecordFields {
     refinedFrom?: string[] | null;
     /**
      * Legacy `decisions.supersedes` column for records whose predecessor was
-     * declared through the supersedeTargets projection rather than the
-     * scope-checked `replaces` command field.
+     * declared before the scope-checked `replaces` command field.
      */
     supersedes?: string | null;
 }
@@ -125,24 +124,6 @@ export interface JudgmentEventMeta {
  * command itself; they mirror what the legacy writers used to persist inline.
  */
 export interface JudgmentProjections {
-    /** Legacy decision_edges rows kept in sync for recall readers. `fromId`
-     * defaults to the appended record; amendment commands may name another row. */
-    decisionEdges?: Array<{
-        fromId?: string;
-        targetId: string;
-        relationship: string;
-        reason?: string | null;
-        weight?: number;
-        createdBy?: string;
-        approvedByUser?: number | null;
-    }>;
-    /**
-     * Rows the command marks as superseded by the appended record. This mirrors
-     * the legacy save surface where an unsigned caller's explicit `supersedes`
-     * relationship moved the named target out of current truth; the command
-     * boundary keeps `replaces` for scope-admitted supersession instead.
-     */
-    supersedeTargets?: string[];
     /** Registry record identity binding (item + actors). */
     recordIdentity?: {
         itemId?: string | null;

package/dist/memory/types.d.ts

@@ -1,4 +1,5 @@
 import type { RecordActor } from '../registry/types.js';
+import type { DecisionCorrection } from './decision-links.js';
 import type { RecordLink } from './judgment-types.js';
 import type { SearchHitDiagnostics, SearchQualityOptions, SearchStrictness } from '../knowledge/search-quality.js';
 /**
@@ -78,8 +79,20 @@ export interface MemoryRecord {
     event_datetime?: number | null;
     /** Maintained outcome projection (SUCCESS | FAILED | PARTIAL | pending). Null when unset. */
     outcome?: string | null;
+    /** On a record search expansion added: the hit it came from and the link it followed there. */
+    reached_through?: MemoryReachedThrough;
     retrieval_diagnostics?: SearchHitDiagnostics;
 }
+export interface MemoryReachedThrough {
+    /** The search hit the link starts from. */
+    from: string;
+    /** The link's relation as seen from that hit (`builds_on`, `built_on_by`, `supersedes_chain`, ...). */
+    relation: string;
+    /** The reason the agent gave for the link; null for the supersedes chain. */
+    reason: string | null;
+    /** Later links that contradict this one, each with its reason. */
+    corrected_by?: DecisionCorrection[];
+}
 export type RecallMemoryOptions = SearchQualityOptions & {
     kind?: MemoryKindFilter;
     scopes?: MemoryScopeRef[];

package/dist/memory/write-adapters.d.ts

@@ -9,7 +9,7 @@
  */
 import type { DatabaseAdapter, DatabaseInstance, DecisionInput } from '../db-manager.js';
 import type { JudgmentAccess } from '../knowledge/judgments.js';
-import type { JudgmentProjections, JsonValue, RecordLink } from './judgment-types.js';
+import type { JsonValue } from './judgment-types.js';
 import type { MemoryScopeRef } from './types.js';
 import type { NormalizedMemoryProvenance } from './provenance.js';
 /** Access for a caller with no signed identity: it is admitted to exactly the
@@ -25,44 +25,6 @@ export declare function writeAccessForProvenance(provenance: NormalizedMemoryPro
 /** Scope refs currently bound to a memory row — the partition a write into
  * that row must be admitted to. */
 export declare function boundScopesOf(adapter: Pick<DatabaseAdapter, 'prepare'>, memoryId: string): MemoryScopeRef[];
-/**
- * Fail-first visibility check for explicitly authored relationship targets,
- * preserving the legacy error contract.
- *
- * Trusted envelopes check visibility strictly inside admitted scopes (unbound
- * legacy rows are not reachable — same as the pre-boundary envelope check).
- * Unsigned callers keep the legacy existence check for the original error
- * text; scope admission is then enforced by the command boundary itself.
- */
-export declare function assertRelationshipTargetsVisible(adapter: Pick<DatabaseAdapter, 'prepare'>, targetIds: readonly string[], admittedScopes: readonly MemoryScopeRef[], trustedEnvelope: boolean): void;
-export interface ExplicitRelationship {
-    type: string;
-    targetId: string;
-}
-/**
- * Map deduplicated legacy relationships onto command fields.
- *
- * Trusted envelopes get the authored form: `supersedes` targets become
- * scope-checked `replaces`, and link-able relations also enter the twin edge
- * graph as explicit `links` — both fail closed inside the boundary.
- *
- * Unsigned callers keep the legacy contract: the adapter already checked that
- * each target exists, so relationships are written only as `decision_edges`
- * projection rows and `supersedes` targets are moved out of current truth
- * through the `supersedeTargets` projection — never as scope-checked authored
- * links the caller was not admitted to.
- */
-export declare function relationshipsToCommandFields(relationships: readonly ExplicitRelationship[], options?: {
-    trusted?: boolean;
-}): {
-    links: RecordLink[];
-    replaces: Array<{
-        id: string;
-        reason: string;
-    }>;
-    decisionEdges: NonNullable<JudgmentProjections['decisionEdges']>;
-    supersedeTargets: string[];
-};
 /**
  * Embedder for the command boundary that preserves the legacy enhanced
  * embedding input.

package/dist/memory/write-adapters.js

@@ -15,8 +15,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.unsignedWriteAccess = unsignedWriteAccess;
 exports.writeAccessForProvenance = writeAccessForProvenance;
 exports.boundScopesOf = boundScopesOf;
-exports.assertRelationshipTargetsVisible = assertRelationshipTargetsVisible;
-exports.relationshipsToCommandFields = relationshipsToCommandFields;
 exports.commandEmbedder = commandEmbedder;
 exports.appendOutcomeAmendment = appendOutcomeAmendment;
 const node_crypto_1 = __importDefault(require("node:crypto"));
@@ -69,102 +67,6 @@ function boundScopesOf(adapter, memoryId) {
         return { kind: record.kind, id: record.external_id };
     });
 }
-/**
- * Fail-first visibility check for explicitly authored relationship targets,
- * preserving the legacy error contract.
- *
- * Trusted envelopes check visibility strictly inside admitted scopes (unbound
- * legacy rows are not reachable — same as the pre-boundary envelope check).
- * Unsigned callers keep the legacy existence check for the original error
- * text; scope admission is then enforced by the command boundary itself.
- */
-function assertRelationshipTargetsVisible(adapter, targetIds, admittedScopes, trustedEnvelope) {
-    for (const targetId of targetIds) {
-        if (trustedEnvelope) {
-            const scopeIds = admittedScopes.map((scope) => (0, db_manager_js_1.buildMemoryScopeId)(scope.kind, scope.id));
-            const placeholders = scopeIds.map(() => '?').join(', ');
-            const visible = scopeIds.length > 0 &&
-                adapter
-                    .prepare(`SELECT 1 FROM decisions d
-             JOIN memory_scope_bindings b ON b.memory_id = d.id
-             WHERE d.id = ? AND b.scope_id IN (${placeholders}) LIMIT 1`)
-                    .get(targetId, ...scopeIds) !== undefined;
-            if (!visible) {
-                const denied = new Error('Relationship target is unavailable');
-                denied.code = 'relationship_target_unavailable';
-                throw denied;
-            }
-            continue;
-        }
-        const target = adapter.prepare('SELECT id FROM decisions WHERE id = ?').get(targetId);
-        if (!target) {
-            throw new Error(`mama.save() relationship target does not exist: ${targetId}`);
-        }
-    }
-}
-const LINK_RELATIONS = new Set([
-    'supersedes',
-    'refines',
-    'contradicts',
-    'mentions',
-    'derived_from',
-    'builds_on',
-    'debates',
-    'synthesizes',
-    'blocks',
-    'next_action_for',
-    'case_member',
-]);
-/**
- * Map deduplicated legacy relationships onto command fields.
- *
- * Trusted envelopes get the authored form: `supersedes` targets become
- * scope-checked `replaces`, and link-able relations also enter the twin edge
- * graph as explicit `links` — both fail closed inside the boundary.
- *
- * Unsigned callers keep the legacy contract: the adapter already checked that
- * each target exists, so relationships are written only as `decision_edges`
- * projection rows and `supersedes` targets are moved out of current truth
- * through the `supersedeTargets` projection — never as scope-checked authored
- * links the caller was not admitted to.
- */
-function relationshipsToCommandFields(relationships, options) {
-    const trusted = options?.trusted === true;
-    const links = [];
-    const replaces = [];
-    const supersedeTargets = [];
-    const decisionEdges = [];
-    const seen = new Set();
-    for (const relationship of relationships) {
-        const key = `${relationship.type}:${relationship.targetId}`;
-        if (seen.has(key))
-            continue;
-        seen.add(key);
-        const reason = `Explicit ${relationship.type} reference in reasoning`;
-        decisionEdges.push({
-            targetId: relationship.targetId,
-            relationship: relationship.type,
-            reason,
-            weight: 1,
-        });
-        if (relationship.type === 'supersedes') {
-            if (trusted) {
-                replaces.push({ id: relationship.targetId, reason });
-            }
-            else {
-                supersedeTargets.push(relationship.targetId);
-            }
-            continue;
-        }
-        if (trusted && LINK_RELATIONS.has(relationship.type)) {
-            links.push({
-                relation: relationship.type,
-                target: { kind: 'memory', id: relationship.targetId },
-            });
-        }
-    }
-    return { links, replaces, decisionEdges, supersedeTargets };
-}
 /**
  * Embedder for the command boundary that preserves the legacy enhanced
  * embedding input.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jungjaehoon/mama-core",
-  "version": "4.1.0",
+  "version": "5.0.0",
   "description": "MAMA Core - Shared modules for Memory-Augmented MCP Assistant",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/dist/knowledge/commitment-revision-migration.d.ts

@@ -1,4 +0,0 @@
-import type { DatabaseAdapter } from '../db-manager.js';
-/** Link every stored commitment revision to the revision it follows. */
-export declare function backfillCommitmentRevisionGraph(adapter: DatabaseAdapter): void;
-//# sourceMappingURL=commitment-revision-migration.d.ts.map

package/dist/knowledge/commitment-revision-migration.js

@@ -1,50 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.backfillCommitmentRevisionGraph = backfillCommitmentRevisionGraph;
-const judgment_edge_js_1 = require("./judgment-edge.js");
-/** Link every stored commitment revision to the revision it follows. */
-function backfillCommitmentRevisionGraph(adapter) {
-    const assignments = adapter
-        .prepare(`SELECT assignment.commitment_id, assignment.revision, assignment.record_id, assignment.operation,
-              assignment.agent_id, assignment.model_run_id, assignment.created_at
-       FROM commitment_assignments AS assignment
-       JOIN commitments AS commitment ON commitment.commitment_id = assignment.commitment_id
-       ORDER BY assignment.commitment_id, assignment.revision`)
-        .all();
-    if (assignments.length === 0)
-        return;
-    const byCommitment = new Map();
-    for (const assignment of assignments) {
-        const rows = byCommitment.get(assignment.commitment_id) ?? [];
-        rows.push(assignment);
-        byCommitment.set(assignment.commitment_id, rows);
-    }
-    const hasEdge = adapter.prepare(`SELECT 1 FROM twin_edges
-     WHERE edge_type = 'builds_on'
-       AND subject_kind = 'memory' AND subject_id = ?
-       AND object_kind = 'memory' AND object_id = ?`);
-    const insertEdge = adapter.prepare(`INSERT OR IGNORE INTO twin_edges (
-       edge_id, edge_type, subject_kind, subject_id, object_kind, object_id,
-       relation_attrs_json, confidence, source, agent_id, model_run_id, content_hash, created_at
-     ) VALUES (?, 'builds_on', 'memory', ?, 'memory', ?, '{}', 1.0, 'code', ?, ?, ?, ?)`);
-    for (const [commitmentId, revisions] of byCommitment) {
-        for (let index = 0; index < revisions.length; index += 1) {
-            const current = revisions[index];
-            if (current.operation === 'create')
-                continue;
-            const previous = revisions[index - 1];
-            if (!previous) {
-                throw new Error(`Commitment ${commitmentId} revision ${current.revision} has no predecessor`);
-            }
-            if (hasEdge.get(current.record_id, previous.record_id))
-                continue;
-            const link = {
-                relation: 'builds_on',
-                target: { kind: 'memory', id: previous.record_id },
-            };
-            const id = (0, judgment_edge_js_1.judgmentEdgeId)(`migration:099:${commitmentId}:${current.revision}`, 0, link.relation, link.target);
-            insertEdge.run(id, current.record_id, previous.record_id, current.agent_id, current.model_run_id, (0, judgment_edge_js_1.judgmentEdgeContentHash)(id, current.record_id, link), current.created_at);
-        }
-    }
-}
-//# sourceMappingURL=commitment-revision-migration.js.map