@noopolis/mneme 0.1.0

package/dist/kernel/support.js

@@ -0,0 +1,207 @@
+import { canonicalScopeKey, memoryScopeId, sanitizePrincipalQualifier } from "../identity/ids.js";
+const isString = (value) => typeof value === "string";
+const hasText = (value) => isString(value) && value.trim().length > 0;
+export const isPlainObject = (value) => typeof value === "object" && value !== null;
+export const asNumber = (value) => {
+    if (typeof value !== "number" || Number.isNaN(value) || value <= 0) {
+        return 0;
+    }
+    return Math.floor(value);
+};
+export const isVisibility = (value) => value === "private" || value === "pair" || value === "team" || value === "room" || value === "global" || value === "public" || value === "sealed";
+export const isSensitivity = (value) => value === "normal" || value === "sensitive" || value === "secret";
+export const isSearchArguments = (value) => hasText(value.scope) && hasText(value.query);
+export const isLocateArguments = (value) => hasText(value.query);
+export const isSummarizeArguments = (value) => hasText(value.scope);
+const isTextContent = (value) => isPlainObject(value) && value.kind === "text" && hasText(value.text);
+const isClaimContent = (value) => isPlainObject(value) &&
+    value.kind === "claim" &&
+    hasText(value.subject) &&
+    hasText(value.predicate) &&
+    hasText(value.object);
+const isDecisionContent = (value) => isPlainObject(value) &&
+    value.kind === "decision" &&
+    hasText(value.decision);
+const isArtifactContent = (value) => isPlainObject(value) &&
+    value.kind === "artifact" &&
+    hasText(value.description);
+const isRelationshipContent = (value) => isPlainObject(value) &&
+    value.kind === "relationship" &&
+    hasText(value.from) &&
+    hasText(value.relation) &&
+    hasText(value.to);
+export const isMemoryContent = (value) => {
+    if (!isPlainObject(value)) {
+        return false;
+    }
+    if (value.kind === "text") {
+        return isTextContent(value);
+    }
+    if (value.kind === "claim") {
+        return isClaimContent(value);
+    }
+    if (value.kind === "decision") {
+        return isDecisionContent(value);
+    }
+    if (value.kind === "artifact") {
+        return isArtifactContent(value);
+    }
+    if (value.kind === "relationship") {
+        return isRelationshipContent(value);
+    }
+    return false;
+};
+export const isRegisterArguments = (value) => isPlainObject(value)
+    && hasText(value.scope)
+    && hasText(value.kind)
+    && hasText(value.visibility)
+    && hasText(value.sensitivity)
+    && hasText(value.source_type)
+    && isVisibility(value.visibility)
+    && isSensitivity(value.sensitivity)
+    && isPlainObject(value.content)
+    && isMemoryContent(value.content)
+    && Array.isArray(value.evidence_event_ids)
+    && value.evidence_event_ids.length > 0
+    && value.evidence_event_ids.every((id) => isString(id));
+export const isForgetArguments = (value) => {
+    if (!isPlainObject(value)) {
+        return false;
+    }
+    return hasText(value.scope)
+        && Array.isArray(value.event_ids)
+        && value.event_ids.length > 0
+        && value.event_ids.every((id) => isString(id));
+};
+export const makeAudit = (call, sources, startAt) => ({
+    request_id: call.request_id,
+    requester: call.envelope.principal,
+    sources: sources.map((event) => event.principal),
+    transport: call.envelope.transport,
+    latency_ms: Date.now() - startAt,
+    argument_hash: canonicalScopeKey(JSON.stringify(call.arguments))
+});
+export const malformed = (call, tool, error, startAt) => ({
+    request_id: call.request_id,
+    tool,
+    decision: "malformed_request",
+    content: [],
+    audit: makeAudit(call, [], startAt),
+    error
+});
+export const unavailable = (call, tool, error, startAt) => ({
+    request_id: call.request_id,
+    tool,
+    decision: "unavailable",
+    content: [],
+    audit: makeAudit(call, [], startAt),
+    error
+});
+export const eventText = (event) => {
+    if (event.content.kind === "text") {
+        return event.content.text;
+    }
+    if (event.content.kind === "claim")
+        return `${event.content.subject} ${event.content.predicate} ${event.content.object}`;
+    if (event.content.kind === "decision")
+        return `${event.content.decision} ${event.content.rationale ?? ""}`.trim();
+    if (event.content.kind === "artifact")
+        return event.content.description;
+    return `${event.content.from} ${event.content.relation} ${event.content.to}`;
+};
+export const resultKind = (kind) => {
+    if (kind === "text")
+        return "memory";
+    if (kind === "decision")
+        return "claim";
+    return kind;
+};
+export const policyText = (decision, text) => {
+    if (decision === "allow_raw")
+        return text;
+    if (decision === "allow_summary" || decision === "allow_redacted_summary") {
+        return text.length > 150 ? `${text.slice(0, 147)}...` : text;
+    }
+    if (decision === "known_but_private") {
+        return "Related private context is available behind policy.";
+    }
+    if (decision === "locate_only") {
+        return "Locate candidates are known, but content is omitted.";
+    }
+    return "Memory was blocked by policy.";
+};
+export const decide = (decisions) => {
+    if (decisions.includes("allow_raw"))
+        return "allow_raw";
+    if (decisions.includes("allow_summary"))
+        return "allow_summary";
+    if (decisions.includes("allow_redacted_summary"))
+        return "allow_redacted_summary";
+    if (decisions.includes("locate_only"))
+        return "locate_only";
+    if (decisions.includes("known_but_private"))
+        return "known_but_private";
+    return "deny";
+};
+export const resolveScope = (scopeInput, requester) => {
+    const scope = canonicalScopeKey(scopeInput.trim().toLowerCase());
+    if (scope === "all") {
+        return "all";
+    }
+    if (scope === "current") {
+        return memoryScopeId(requester);
+    }
+    if (scope === "global") {
+        return memoryScopeId({ ...requester, scope: "global" });
+    }
+    return canonicalScopeKey(scopeInput);
+};
+export const sanitizePrincipal = (principal) => ({
+    ...principal,
+    qualifier: principal.qualifier ? sanitizePrincipalQualifier(principal.qualifier) : undefined
+});
+export const collectTombstones = (events) => {
+    const redacted = new Set();
+    for (const event of events) {
+        if (event.type === "memory.forgotten") {
+            for (const id of event.parentEventIds) {
+                redacted.add(id);
+            }
+        }
+    }
+    return redacted;
+};
+export const isRecallableMemoryEvent = (event) => event.type !== "memory.located" &&
+    event.type !== "memory.denied" &&
+    event.type !== "memory.forgotten";
+export const matchesQuery = (event, query) => {
+    const normalized = eventText(event).toLowerCase();
+    const tokens = query.toLowerCase()
+        .split(/\W+/u)
+        .map((value) => value.trim())
+        .filter((value) => value.length > 2);
+    if (tokens.length === 0) {
+        return true;
+    }
+    return tokens.some((token) => normalized.includes(token));
+};
+export const canExposeEventId = (decision) => decision === "allow_raw" || decision === "allow_summary" || decision === "allow_redacted_summary";
+export const locateCandidateId = (event) => `${event.principal.agentId}|${event.principal.scope}|${event.principal.qualifier ?? ""}`;
+export const hasInvalidV1Envelope = (version) => version !== "mneme.memory.tool.v1";
+export const makeSearchResult = (decision, event) => ({
+    kind: resultKind(event.content.kind),
+    text: policyText(decision, eventText(event)),
+    event_ids: canExposeEventId(decision) ? [event.id] : [],
+    scope: event.scope,
+    principal: event.principal,
+    confidence: 1,
+    redactions: decision === "allow_redacted_summary" || decision === "known_but_private" ? ["redacted"] : []
+});
+export const makeLocateResult = (entry) => ({
+    kind: "locate",
+    event_ids: canExposeEventId(entry.decision) ? entry.eventIds : [],
+    scope: entry.scope,
+    principal: entry.event.principal,
+    confidence: Math.min(1, entry.score / 10),
+    redactions: ["content-omitted"]
+});

package/dist/mcp/config.d.ts

@@ -0,0 +1,23 @@
+import type { MemoryPrincipalRef, MemoryRuntime, MemoryToolExecutionContext } from "../contract/types.js";
+export interface MnemeMcpServerConfig {
+    runtimeHomePath: string;
+    agentId: string;
+    agentScope?: MemoryPrincipalRef["scope"];
+    agentQualifier?: string;
+    conversationScope?: string;
+    audienceKey?: string;
+    policyVersion?: string;
+    source?: string;
+    tokenBudget?: number;
+    runtime?: MemoryRuntime;
+}
+export interface ResolvedMnemeMcpConfig extends Required<Pick<MnemeMcpServerConfig, "runtimeHomePath" | "agentId" | "conversationScope" | "audienceKey" | "policyVersion">> {
+    principal: MemoryPrincipalRef;
+    source?: string;
+    tokenBudget?: number;
+    runtime: MemoryRuntime;
+}
+export declare const resolveMnemeMcpConfig: (config: MnemeMcpServerConfig) => ResolvedMnemeMcpConfig;
+export declare const createMcpToolContext: (config: ResolvedMnemeMcpConfig, toolName: string) => MemoryToolExecutionContext;
+export declare const parseMnemeMcpArgs: (argv: string[], env?: NodeJS.ProcessEnv) => MnemeMcpServerConfig;
+//# sourceMappingURL=config.d.ts.map

package/dist/mcp/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/mcp/config.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,kBAAkB,EAClB,aAAa,EACb,0BAA0B,EAC3B,MAAM,sBAAsB,CAAC;AAG9B,MAAM,WAAW,oBAAoB;IACnC,eAAe,EAAE,MAAM,CAAC;IACxB,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,kBAAkB,CAAC,OAAO,CAAC,CAAC;IACzC,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,OAAO,CAAC,EAAE,aAAa,CAAC;CACzB;AAED,MAAM,WAAW,sBAAuB,SAAQ,QAAQ,CACtD,IAAI,CAAC,oBAAoB,EAAE,iBAAiB,GAAG,SAAS,GAAG,mBAAmB,GAAG,aAAa,GAAG,eAAe,CAAC,CAClH;IACC,SAAS,EAAE,kBAAkB,CAAC;IAC9B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,OAAO,EAAE,aAAa,CAAC;CACxB;AAED,eAAO,MAAM,qBAAqB,GAAI,QAAQ,oBAAoB,KAAG,sBAuBpE,CAAC;AAEF,eAAO,MAAM,oBAAoB,GAC/B,QAAQ,sBAAsB,EAC9B,UAAU,MAAM,KACf,0BAYF,CAAC;AAEF,eAAO,MAAM,iBAAiB,GAC5B,MAAM,MAAM,EAAE,EACd,MAAK,MAAM,CAAC,UAAwB,KACnC,oBAwCF,CAAC"}

package/dist/mcp/config.js

@@ -0,0 +1,76 @@
+import { memoryScopeId } from "../identity/ids.js";
+import { createMemoryRuntime } from "../runtime/runtime.js";
+export const resolveMnemeMcpConfig = (config) => {
+    const principal = {
+        agentId: config.agentId,
+        scope: config.agentScope ?? "global",
+        qualifier: config.agentQualifier
+    };
+    return {
+        runtimeHomePath: config.runtimeHomePath,
+        agentId: config.agentId,
+        principal,
+        conversationScope: config.conversationScope ?? memoryScopeId(principal),
+        audienceKey: config.audienceKey ?? config.agentId,
+        policyVersion: config.policyVersion ?? "memory-policy.v1",
+        source: config.source,
+        tokenBudget: config.tokenBudget,
+        runtime: config.runtime ?? createMemoryRuntime({
+            agentId: config.agentId,
+            runtimeHomePath: config.runtimeHomePath,
+            source: config.source,
+            tokenBudget: config.tokenBudget
+        })
+    };
+};
+export const createMcpToolContext = (config, toolName) => {
+    const now = Date.now();
+    return {
+        wakeId: `mcp-${now}`,
+        threadId: `mcp:${config.audienceKey}`,
+        principal: config.principal,
+        conversationScope: config.conversationScope,
+        audienceKey: config.audienceKey,
+        policyVersion: config.policyVersion,
+        transport: "mcp",
+        nonce: `mcp:${toolName}:${now}`
+    };
+};
+export const parseMnemeMcpArgs = (argv, env = process.env) => {
+    const values = new Map();
+    for (let index = 0; index < argv.length; index += 1) {
+        const current = argv[index];
+        if (!current.startsWith("--")) {
+            continue;
+        }
+        const key = current.slice(2);
+        const next = argv[index + 1];
+        if (!next || next.startsWith("--")) {
+            values.set(key, "true");
+            continue;
+        }
+        values.set(key, next);
+        index += 1;
+    }
+    const runtimeHomePath = values.get("runtime-home") ?? env.MNEME_RUNTIME_HOME;
+    const agentId = values.get("agent-id") ?? env.MNEME_AGENT_ID;
+    if (!runtimeHomePath) {
+        throw new Error("mneme mcp requires --runtime-home or MNEME_RUNTIME_HOME");
+    }
+    if (!agentId) {
+        throw new Error("mneme mcp requires --agent-id or MNEME_AGENT_ID");
+    }
+    const tokenBudgetText = values.get("token-budget") ?? env.MNEME_TOKEN_BUDGET;
+    const tokenBudget = tokenBudgetText ? Number.parseInt(tokenBudgetText, 10) : undefined;
+    return {
+        runtimeHomePath,
+        agentId,
+        agentScope: (values.get("agent-scope") ?? env.MNEME_AGENT_SCOPE),
+        agentQualifier: values.get("agent-qualifier") ?? env.MNEME_AGENT_QUALIFIER,
+        conversationScope: values.get("conversation-scope") ?? env.MNEME_CONVERSATION_SCOPE,
+        audienceKey: values.get("audience-key") ?? env.MNEME_AUDIENCE_KEY,
+        policyVersion: values.get("policy-version") ?? env.MNEME_POLICY_VERSION,
+        source: values.get("source") ?? env.MNEME_SOURCE,
+        tokenBudget: Number.isFinite(tokenBudget) ? tokenBudget : undefined
+    };
+};

package/dist/mcp/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./config.js";
+export * from "./server.js";
+export * from "./schemas.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/mcp/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/mcp/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,cAAc,CAAC"}

package/dist/mcp/index.js

@@ -0,0 +1,3 @@
+export * from "./config.js";
+export * from "./server.js";
+export * from "./schemas.js";

package/dist/mcp/schemas.d.ts

@@ -0,0 +1,150 @@
+import * as z from "zod/v4";
+export declare const searchInputSchema: {
+    scope: z.ZodString;
+    query: z.ZodString;
+    limit: z.ZodOptional<z.ZodNumber>;
+};
+export declare const locateInputSchema: {
+    query: z.ZodString;
+    limit: z.ZodOptional<z.ZodNumber>;
+    active_scope: z.ZodOptional<z.ZodString>;
+};
+export declare const registerInputSchema: {
+    scope: z.ZodString;
+    kind: z.ZodString;
+    content: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"text">;
+        text: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"claim">;
+        subject: z.ZodString;
+        predicate: z.ZodString;
+        object: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"decision">;
+        decision: z.ZodString;
+        rationale: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"artifact">;
+        path: z.ZodOptional<z.ZodString>;
+        uri: z.ZodOptional<z.ZodString>;
+        description: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"relationship">;
+        from: z.ZodString;
+        relation: z.ZodString;
+        to: z.ZodString;
+    }, z.core.$strip>], "kind">;
+    visibility: z.ZodEnum<{
+        global: "global";
+        team: "team";
+        room: "room";
+        pair: "pair";
+        private: "private";
+        public: "public";
+        sealed: "sealed";
+    }>;
+    sensitivity: z.ZodEnum<{
+        normal: "normal";
+        sensitive: "sensitive";
+        secret: "secret";
+    }>;
+    evidence_event_ids: z.ZodArray<z.ZodString>;
+    source_type: z.ZodString;
+    confidence: z.ZodOptional<z.ZodNumber>;
+    principal: z.ZodOptional<z.ZodObject<{
+        agentId: z.ZodString;
+        scope: z.ZodEnum<{
+            global: "global";
+            team: "team";
+            room: "room";
+            pair: "pair";
+            task: "task";
+            role: "role";
+            artifact: "artifact";
+        }>;
+        qualifier: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+};
+export declare const summarizeInputSchema: {
+    scope: z.ZodString;
+    horizon: z.ZodOptional<z.ZodNumber>;
+};
+export declare const forgetInputSchema: {
+    scope: z.ZodString;
+    event_ids: z.ZodArray<z.ZodString>;
+    reason: z.ZodOptional<z.ZodString>;
+};
+export declare const schemaForModelToolName: (name: string) => {
+    scope: z.ZodString;
+    query: z.ZodString;
+    limit: z.ZodOptional<z.ZodNumber>;
+} | {
+    query: z.ZodString;
+    limit: z.ZodOptional<z.ZodNumber>;
+    active_scope: z.ZodOptional<z.ZodString>;
+} | {
+    scope: z.ZodString;
+    kind: z.ZodString;
+    content: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"text">;
+        text: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"claim">;
+        subject: z.ZodString;
+        predicate: z.ZodString;
+        object: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"decision">;
+        decision: z.ZodString;
+        rationale: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"artifact">;
+        path: z.ZodOptional<z.ZodString>;
+        uri: z.ZodOptional<z.ZodString>;
+        description: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"relationship">;
+        from: z.ZodString;
+        relation: z.ZodString;
+        to: z.ZodString;
+    }, z.core.$strip>], "kind">;
+    visibility: z.ZodEnum<{
+        global: "global";
+        team: "team";
+        room: "room";
+        pair: "pair";
+        private: "private";
+        public: "public";
+        sealed: "sealed";
+    }>;
+    sensitivity: z.ZodEnum<{
+        normal: "normal";
+        sensitive: "sensitive";
+        secret: "secret";
+    }>;
+    evidence_event_ids: z.ZodArray<z.ZodString>;
+    source_type: z.ZodString;
+    confidence: z.ZodOptional<z.ZodNumber>;
+    principal: z.ZodOptional<z.ZodObject<{
+        agentId: z.ZodString;
+        scope: z.ZodEnum<{
+            global: "global";
+            team: "team";
+            room: "room";
+            pair: "pair";
+            task: "task";
+            role: "role";
+            artifact: "artifact";
+        }>;
+        qualifier: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+} | {
+    scope: z.ZodString;
+    horizon: z.ZodOptional<z.ZodNumber>;
+} | {
+    scope: z.ZodString;
+    event_ids: z.ZodArray<z.ZodString>;
+    reason: z.ZodOptional<z.ZodString>;
+};
+//# sourceMappingURL=schemas.d.ts.map

package/dist/mcp/schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../src/mcp/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,QAAQ,CAAC;AAE5B,eAAO,MAAM,iBAAiB;;;;CAI7B,CAAC;AAEF,eAAO,MAAM,iBAAiB;;;;CAI7B,CAAC;AAgBF,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAU/B,CAAC;AAEF,eAAO,MAAM,oBAAoB;;;CAGhC,CAAC;AAEF,eAAO,MAAM,iBAAiB;;;;CAI7B,CAAC;AAEF,eAAO,MAAM,sBAAsB,GAAI,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAMlD,CAAC"}

package/dist/mcp/schemas.js

@@ -0,0 +1,54 @@
+import * as z from "zod/v4";
+export const searchInputSchema = {
+    scope: z.string().describe("Scope alias or canonical scope id. Use current, global, or all when appropriate."),
+    query: z.string().describe("Search query."),
+    limit: z.number().optional().describe("Maximum result count.")
+};
+export const locateInputSchema = {
+    query: z.string().describe("What to locate in memory."),
+    limit: z.number().optional().describe("Maximum candidate count."),
+    active_scope: z.string().optional().describe("Optional active scope hint.")
+};
+const memoryContentSchema = z.discriminatedUnion("kind", [
+    z.object({ kind: z.literal("text"), text: z.string() }),
+    z.object({ kind: z.literal("claim"), subject: z.string(), predicate: z.string(), object: z.string() }),
+    z.object({ kind: z.literal("decision"), decision: z.string(), rationale: z.string().optional() }),
+    z.object({ kind: z.literal("artifact"), path: z.string().optional(), uri: z.string().optional(), description: z.string() }),
+    z.object({ kind: z.literal("relationship"), from: z.string(), relation: z.string(), to: z.string() })
+]);
+const principalSchema = z.object({
+    agentId: z.string(),
+    scope: z.enum(["global", "team", "room", "pair", "task", "role", "artifact"]),
+    qualifier: z.string().optional()
+});
+export const registerInputSchema = {
+    scope: z.string().describe("Scope alias or canonical scope id where the memory belongs."),
+    kind: z.string().describe("Memory content kind."),
+    content: memoryContentSchema.describe("Structured memory content."),
+    visibility: z.enum(["private", "pair", "team", "room", "global", "public", "sealed"]),
+    sensitivity: z.enum(["normal", "sensitive", "secret"]),
+    evidence_event_ids: z.array(z.string()).min(1).describe("Event ids that justify the memory."),
+    source_type: z.string().describe("Source label for the registered memory."),
+    confidence: z.number().optional().describe("Confidence from 0 to 1."),
+    principal: principalSchema.optional().describe("Optional principal override for the stored memory.")
+};
+export const summarizeInputSchema = {
+    scope: z.string().describe("Scope alias or canonical scope id to summarize."),
+    horizon: z.number().optional().describe("Approximate number of recent memories to include.")
+};
+export const forgetInputSchema = {
+    scope: z.string().describe("Scope alias or canonical scope id for the tombstone."),
+    event_ids: z.array(z.string()).min(1).describe("Memory event ids to tombstone."),
+    reason: z.string().optional().describe("Why these memories should be forgotten.")
+};
+export const schemaForModelToolName = (name) => {
+    if (name === "memory_search")
+        return searchInputSchema;
+    if (name === "memory_locate")
+        return locateInputSchema;
+    if (name === "memory_register")
+        return registerInputSchema;
+    if (name === "memory_summarize")
+        return summarizeInputSchema;
+    return forgetInputSchema;
+};

package/dist/mcp/server.d.ts

@@ -0,0 +1,5 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { type MnemeMcpServerConfig } from "./config.js";
+export declare const createMnemeMcpServer: (config: MnemeMcpServerConfig) => McpServer;
+export declare const connectMnemeMcpStdio: (config: MnemeMcpServerConfig) => Promise<McpServer>;
+//# sourceMappingURL=server.d.ts.map

package/dist/mcp/server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../src/mcp/server.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAMpE,OAAO,EAGL,KAAK,oBAAoB,EAC1B,MAAM,aAAa,CAAC;AAqBrB,eAAO,MAAM,oBAAoB,GAAI,QAAQ,oBAAoB,KAAG,SA2BnE,CAAC;AAEF,eAAO,MAAM,oBAAoB,GAAU,QAAQ,oBAAoB,KAAG,OAAO,CAAC,SAAS,CAI1F,CAAC"}

package/dist/mcp/server.js

@@ -0,0 +1,45 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { createMemoryToolDescriptors } from "../contract/toolDescriptors.js";
+import { createMcpToolContext, resolveMnemeMcpConfig } from "./config.js";
+import { schemaForModelToolName } from "./schemas.js";
+const annotationsFor = (name) => {
+    if (name === "memory_search" || name === "memory_locate") {
+        return { readOnlyHint: true, openWorldHint: false };
+    }
+    if (name === "memory_forget") {
+        return { destructiveHint: true, openWorldHint: false };
+    }
+    return { openWorldHint: false };
+};
+const toolResult = (result) => ({
+    content: [{
+            type: "text",
+            text: JSON.stringify(result, null, 2)
+        }],
+    structuredContent: result
+});
+export const createMnemeMcpServer = (config) => {
+    const resolved = resolveMnemeMcpConfig(config);
+    const server = new McpServer({
+        name: "mneme",
+        version: "0.1.0"
+    });
+    for (const descriptor of createMemoryToolDescriptors(resolved.runtime.kernel)) {
+        server.registerTool(descriptor.modelName, {
+            title: descriptor.label,
+            description: descriptor.description,
+            inputSchema: schemaForModelToolName(descriptor.modelName),
+            annotations: annotationsFor(descriptor.modelName)
+        }, async (args) => {
+            const result = await descriptor.invoke(args, createMcpToolContext(resolved, descriptor.modelName));
+            return toolResult(result);
+        });
+    }
+    return server;
+};
+export const connectMnemeMcpStdio = async (config) => {
+    const server = createMnemeMcpServer(config);
+    await server.connect(new StdioServerTransport());
+    return server;
+};

package/dist/policy/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./policy.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/policy/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/policy/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC"}

package/dist/policy/index.js

@@ -0,0 +1 @@
+export * from "./policy.js";

package/dist/policy/policy.d.ts

@@ -0,0 +1,9 @@
+import type { MemoryDecision, MemoryPolicyInput, MemoryPrincipalRef } from "../contract/types.js";
+export declare const memoryPolicy: ({ request, candidate }: MemoryPolicyInput) => {
+    decision: MemoryDecision;
+    reason: string;
+};
+export declare const memoryPriority: (request: MemoryPrincipalRef, candidate: MemoryPrincipalRef) => number;
+export declare const shouldRecordDecisionEvent: (decision: MemoryDecision) => boolean;
+export declare const principalKey: (principal: MemoryPrincipalRef) => string;
+//# sourceMappingURL=policy.d.ts.map

package/dist/policy/policy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"policy.d.ts","sourceRoot":"","sources":["../../src/policy/policy.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,cAAc,EACd,iBAAiB,EAGjB,kBAAkB,EACnB,MAAM,sBAAsB,CAAC;AAuD9B,eAAO,MAAM,YAAY,GAAI,wBAAwB,iBAAiB,KAAG;IACvE,QAAQ,EAAE,cAAc,CAAC;IACzB,MAAM,EAAE,MAAM,CAAC;CAgGhB,CAAC;AAEF,eAAO,MAAM,cAAc,GAAI,SAAS,kBAAkB,EAAE,WAAW,kBAAkB,KAAG,MACzD,CAAC;AAEpC,eAAO,MAAM,yBAAyB,GAAI,UAAU,cAAc,KAAG,OACX,CAAC;AAE3D,eAAO,MAAM,YAAY,2CAAwB,CAAC"}