mem-os-python 1.6.27__py3-none-any.whl

memos/_js/procedural.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"procedural.js","sourceRoot":"","sources":["../src/procedural.ts"],"names":[],"mappings":"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"}

memos/_js/project-config.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Memory-as-code: optional project-level configuration from a
+ * `.memos.json` file, resolved by walking up from the working directory
+ * (like AGENTS.md) so monorepo subdirectories inherit the root policy.
+ *
+ * The file commits memory POLICY to version control — scope defaults,
+ * consolidation knobs, embedding routing, the NAME of the env var that
+ * holds the encryption key (never the key itself):
+ *
+ * ```json
+ * {
+ *   "scope": { "user": "alice", "agent": "coder" },
+ *   "consolidation": { "minRetentionScore": 0.2, "decayHalfLifeDays": 60 },
+ *   "embeddings": { "provider": "openai-compatible", "model": "LFM2.5-Embedding-350M-BF16", "baseUrl": "http://127.0.0.1:8080/v1" },
+ *   "privacy": { "cipherKeyEnv": "MEMOS_KEY" }
+ * }
+ * ```
+ *
+ * @module @mem-os/project-config
+ */
+export interface MemosProjectConfig {
+    scope?: {
+        user?: string;
+        agent?: string;
+    };
+    consolidation?: {
+        minRetentionScore?: number;
+        decayHalfLifeDays?: number;
+        olderThanDays?: number;
+    };
+    embeddings?: {
+        provider?: string;
+        model?: string;
+        baseUrl?: string;
+        dimensions?: number;
+    };
+    /**
+     * Image memory. `enabled` turns on the caption track (images are
+     * stored with a searchable caption); `clip.enabled` additionally
+     * turns on the CLIP pixel track. Overridable per-invocation with
+     * `--vision` / `--vision-clip` or MEMOS_VISION / MEMOS_VISION_CLIP.
+     */
+    vision?: {
+        enabled?: boolean;
+        clip?: {
+            enabled?: boolean;
+        };
+        storeRoot?: string;
+        maxImageBytes?: number;
+    };
+    privacy?: {
+        /** Environment variable that holds the encryption key. */
+        cipherKeyEnv?: string;
+    };
+}
+export declare const PROJECT_CONFIG_FILE = ".memos.json";
+/**
+ * Find and parse the nearest `.memos.json`, walking up from `dir` to the
+ * filesystem root. Returns null when no file exists. Throws with the file
+ * path when the file exists but is malformed.
+ */
+export declare function loadProjectConfig(dir?: string): MemosProjectConfig | null;
+/**
+ * The env var name that holds the encryption key, per project config.
+ * Default: MEMOS_KEY.
+ */
+export declare function cipherKeyEnvName(config: MemosProjectConfig | null): string;
+//# sourceMappingURL=project-config.d.ts.map

memos/_js/project-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"project-config.d.ts","sourceRoot":"","sources":["../src/project-config.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAKH,MAAM,WAAW,kBAAkB;IACjC,KAAK,CAAC,EAAE;QACN,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,KAAK,CAAC,EAAE,MAAM,CAAC;KAChB,CAAC;IACF,aAAa,CAAC,EAAE;QACd,iBAAiB,CAAC,EAAE,MAAM,CAAC;QAC3B,iBAAiB,CAAC,EAAE,MAAM,CAAC;QAC3B,aAAa,CAAC,EAAE,MAAM,CAAC;KACxB,CAAC;IACF,UAAU,CAAC,EAAE;QACX,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,UAAU,CAAC,EAAE,MAAM,CAAC;KACrB,CAAC;IACF;;;;;OAKG;IACH,MAAM,CAAC,EAAE;QACP,OAAO,CAAC,EAAE,OAAO,CAAC;QAClB,IAAI,CAAC,EAAE;YAAE,OAAO,CAAC,EAAE,OAAO,CAAA;SAAE,CAAC;QAC7B,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,aAAa,CAAC,EAAE,MAAM,CAAC;KACxB,CAAC;IACF,OAAO,CAAC,EAAE;QACR,0DAA0D;QAC1D,YAAY,CAAC,EAAE,MAAM,CAAC;KACvB,CAAC;CACH;AAED,eAAO,MAAM,mBAAmB,gBAAgB,CAAC;AAEjD;;;;GAIG;AACH,wBAAgB,iBAAiB,CAC/B,GAAG,GAAE,MAAsB,GAC1B,kBAAkB,GAAG,IAAI,CAwB3B;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,kBAAkB,GAAG,IAAI,GAAG,MAAM,CAE1E"}

memos/_js/project-config.js

@@ -0,0 +1,59 @@
+/**
+ * Memory-as-code: optional project-level configuration from a
+ * `.memos.json` file, resolved by walking up from the working directory
+ * (like AGENTS.md) so monorepo subdirectories inherit the root policy.
+ *
+ * The file commits memory POLICY to version control — scope defaults,
+ * consolidation knobs, embedding routing, the NAME of the env var that
+ * holds the encryption key (never the key itself):
+ *
+ * ```json
+ * {
+ *   "scope": { "user": "alice", "agent": "coder" },
+ *   "consolidation": { "minRetentionScore": 0.2, "decayHalfLifeDays": 60 },
+ *   "embeddings": { "provider": "openai-compatible", "model": "LFM2.5-Embedding-350M-BF16", "baseUrl": "http://127.0.0.1:8080/v1" },
+ *   "privacy": { "cipherKeyEnv": "MEMOS_KEY" }
+ * }
+ * ```
+ *
+ * @module @mem-os/project-config
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+export const PROJECT_CONFIG_FILE = ".memos.json";
+/**
+ * Find and parse the nearest `.memos.json`, walking up from `dir` to the
+ * filesystem root. Returns null when no file exists. Throws with the file
+ * path when the file exists but is malformed.
+ */
+export function loadProjectConfig(dir = process.cwd()) {
+    let current = resolve(dir);
+    for (;;) {
+        const candidate = resolve(current, PROJECT_CONFIG_FILE);
+        if (existsSync(candidate)) {
+            try {
+                const parsed = JSON.parse(readFileSync(candidate, "utf8"));
+                if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+                    throw new Error("config must be a JSON object");
+                }
+                return parsed;
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                throw new Error(`Malformed ${PROJECT_CONFIG_FILE} at ${candidate}: ${message}`);
+            }
+        }
+        const parent = dirname(current);
+        if (parent === current)
+            return null;
+        current = parent;
+    }
+}
+/**
+ * The env var name that holds the encryption key, per project config.
+ * Default: MEMOS_KEY.
+ */
+export function cipherKeyEnvName(config) {
+    return config?.privacy?.cipherKeyEnv || "MEMOS_KEY";
+}
+//# sourceMappingURL=project-config.js.map

memos/_js/project-config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"project-config.js","sourceRoot":"","sources":["../src/project-config.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AACnD,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAoC7C,MAAM,CAAC,MAAM,mBAAmB,GAAG,aAAa,CAAC;AAEjD;;;;GAIG;AACH,MAAM,UAAU,iBAAiB,CAC/B,GAAG,GAAW,OAAO,CAAC,GAAG,EAAE;IAE3B,IAAI,OAAO,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC;IAC3B,SAAS,CAAC;QACR,MAAM,SAAS,GAAG,OAAO,CAAC,OAAO,EAAE,mBAAmB,CAAC,CAAC;QACxD,IAAI,UAAU,CAAC,SAAS,CAAC,EAAE,CAAC;YAC1B,IAAI,CAAC;gBACH,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CACvB,YAAY,CAAC,SAAS,EAAE,MAAM,CAAC,CACV,CAAC;gBACxB,IAAI,CAAC,MAAM,IAAI,OAAO,MAAM,KAAK,QAAQ,IAAI,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC;oBACnE,MAAM,IAAI,KAAK,CAAC,8BAA8B,CAAC,CAAC;gBAClD,CAAC;gBACD,OAAO,MAAM,CAAC;YAChB,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,MAAM,OAAO,GAAG,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;gBACvE,MAAM,IAAI,KAAK,CACb,aAAa,mBAAmB,OAAO,SAAS,KAAK,OAAO,EAAE,CAC/D,CAAC;YACJ,CAAC;QACH,CAAC;QACD,MAAM,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;QAChC,IAAI,MAAM,KAAK,OAAO;YAAE,OAAO,IAAI,CAAC;QACpC,OAAO,GAAG,MAAM,CAAC;IACnB,CAAC;AACH,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,gBAAgB,CAAC,MAAiC;IAChE,OAAO,MAAM,EAAE,OAAO,EAAE,YAAY,IAAI,WAAW,CAAC;AACtD,CAAC"}

memos/_js/proof-of-forgetting.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Cryptographic proof of forgetting.
+ *
+ * When a memory is deleted via `forget()`, memos already writes a
+ * tombstone entry to the hash-chained tamper log. This module adds:
+ *
+ * - `proveForget()`: Export a signed deletion certificate containing
+ *   the node ID, deletion timestamp, content hash, and tamper-log
+ *   sequence number. The certificate proves *what* was deleted and *when*.
+ * - `verifyForget()`: Verify a certificate against the tamper log —
+ *   checks the entry exists, the chain is intact, and the hashes match.
+ *
+ * This is the "prove it" for GDPR Article 17: not "trust us, it's deleted"
+ * but a cryptographically verifiable artifact. Zero competitors ship this.
+ */
+import type { TamperLogEntry } from "./types.js";
+export interface DeletionCertificate {
+    /** The deleted node's ID. */
+    nodeId: string;
+    /** Unix ms when the deletion occurred. */
+    deletedAt: number;
+    /** SHA-256 hex of the deleted node's content. */
+    contentHash: string;
+    /** Tamper-log sequence number of the forget entry. */
+    tamperSeq: number;
+    /** Hash of the tamper-log entry (chain link). */
+    entryHash: string;
+    /** Previous entry hash (chain continuity). */
+    prevHash: string;
+    /** Certificate format version. */
+    version: 1;
+}
+/**
+ * Create a deletion certificate from a tamper-log forget entry.
+ *
+ * @param entry - The tamper-log entry with op="forget" for the deleted node.
+ * @returns A verifiable deletion certificate, or null if the entry is not a forget.
+ */
+export declare function createDeletionCertificate(entry: TamperLogEntry): DeletionCertificate | null;
+/**
+ * Verify a deletion certificate against tamper-log entries.
+ *
+ * Checks:
+ * 1. A forget entry exists at the certificate's sequence number.
+ * 2. The entry's hashes match the certificate.
+ * 3. The chain is intact (prevHash links correctly).
+ *
+ * @param cert - The certificate to verify.
+ * @param entries - Tamper-log entries (must include the forget entry and its predecessor).
+ * @returns True if the certificate is valid.
+ */
+export declare function verifyDeletionCertificate(cert: DeletionCertificate, entries: TamperLogEntry[]): boolean;
+/**
+ * Hash content for the certificate (SHA-256 hex).
+ */
+export declare function hashContent(content: string): string;
+//# sourceMappingURL=proof-of-forgetting.d.ts.map

memos/_js/proof-of-forgetting.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"proof-of-forgetting.d.ts","sourceRoot":"","sources":["../src/proof-of-forgetting.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAGH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAEjD,MAAM,WAAW,mBAAmB;IAClC,6BAA6B;IAC7B,MAAM,EAAE,MAAM,CAAC;IACf,0CAA0C;IAC1C,SAAS,EAAE,MAAM,CAAC;IAClB,iDAAiD;IACjD,WAAW,EAAE,MAAM,CAAC;IACpB,sDAAsD;IACtD,SAAS,EAAE,MAAM,CAAC;IAClB,iDAAiD;IACjD,SAAS,EAAE,MAAM,CAAC;IAClB,8CAA8C;IAC9C,QAAQ,EAAE,MAAM,CAAC;IACjB,kCAAkC;IAClC,OAAO,EAAE,CAAC,CAAC;CACZ;AAED;;;;;GAKG;AACH,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,cAAc,GACpB,mBAAmB,GAAG,IAAI,CAY5B;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,yBAAyB,CACvC,IAAI,EAAE,mBAAmB,EACzB,OAAO,EAAE,cAAc,EAAE,GACxB,OAAO,CAsBT;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAEnD"}

memos/_js/proof-of-forgetting.js

@@ -0,0 +1,80 @@
+/**
+ * Cryptographic proof of forgetting.
+ *
+ * When a memory is deleted via `forget()`, memos already writes a
+ * tombstone entry to the hash-chained tamper log. This module adds:
+ *
+ * - `proveForget()`: Export a signed deletion certificate containing
+ *   the node ID, deletion timestamp, content hash, and tamper-log
+ *   sequence number. The certificate proves *what* was deleted and *when*.
+ * - `verifyForget()`: Verify a certificate against the tamper log —
+ *   checks the entry exists, the chain is intact, and the hashes match.
+ *
+ * This is the "prove it" for GDPR Article 17: not "trust us, it's deleted"
+ * but a cryptographically verifiable artifact. Zero competitors ship this.
+ */
+import { createHash } from "node:crypto";
+/**
+ * Create a deletion certificate from a tamper-log forget entry.
+ *
+ * @param entry - The tamper-log entry with op="forget" for the deleted node.
+ * @returns A verifiable deletion certificate, or null if the entry is not a forget.
+ */
+export function createDeletionCertificate(entry) {
+    if (entry.op !== "forget")
+        return null;
+    return {
+        nodeId: entry.nodeId,
+        deletedAt: entry.ts,
+        contentHash: entry.nodeHash,
+        tamperSeq: entry.seq,
+        entryHash: entry.entryHash,
+        prevHash: entry.prevHash,
+        version: 1,
+    };
+}
+/**
+ * Verify a deletion certificate against tamper-log entries.
+ *
+ * Checks:
+ * 1. A forget entry exists at the certificate's sequence number.
+ * 2. The entry's hashes match the certificate.
+ * 3. The chain is intact (prevHash links correctly).
+ *
+ * @param cert - The certificate to verify.
+ * @param entries - Tamper-log entries (must include the forget entry and its predecessor).
+ * @returns True if the certificate is valid.
+ */
+export function verifyDeletionCertificate(cert, entries) {
+    if (cert.version !== 1)
+        return false;
+    const entry = entries.find((e) => e.seq === cert.tamperSeq && e.op === "forget");
+    if (!entry)
+        return false;
+    // Hashes must match
+    if (entry.nodeId !== cert.nodeId)
+        return false;
+    if (entry.nodeHash !== cert.contentHash)
+        return false;
+    if (entry.entryHash !== cert.entryHash)
+        return false;
+    if (entry.prevHash !== cert.prevHash)
+        return false;
+    if (entry.ts !== cert.deletedAt)
+        return false;
+    // Chain continuity: prevHash must match the previous entry's hash
+    const prev = entries.find((e) => e.seq === cert.tamperSeq - 1);
+    if (prev && prev.entryHash !== cert.prevHash)
+        return false;
+    // If no predecessor (seq 0), prevHash should be the genesis marker
+    if (!prev && cert.tamperSeq !== 0)
+        return false;
+    return true;
+}
+/**
+ * Hash content for the certificate (SHA-256 hex).
+ */
+export function hashContent(content) {
+    return createHash("sha256").update(content, "utf8").digest("hex");
+}
+//# sourceMappingURL=proof-of-forgetting.js.map

memos/_js/proof-of-forgetting.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"proof-of-forgetting.js","sourceRoot":"","sources":["../src/proof-of-forgetting.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAoBzC;;;;;GAKG;AACH,MAAM,UAAU,yBAAyB,CACvC,KAAqB;IAErB,IAAI,KAAK,CAAC,EAAE,KAAK,QAAQ;QAAE,OAAO,IAAI,CAAC;IAEvC,OAAO;QACL,MAAM,EAAE,KAAK,CAAC,MAAM;QACpB,SAAS,EAAE,KAAK,CAAC,EAAE;QACnB,WAAW,EAAE,KAAK,CAAC,QAAQ;QAC3B,SAAS,EAAE,KAAK,CAAC,GAAG;QACpB,SAAS,EAAE,KAAK,CAAC,SAAS;QAC1B,QAAQ,EAAE,KAAK,CAAC,QAAQ;QACxB,OAAO,EAAE,CAAC;KACX,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,yBAAyB,CACvC,IAAyB,EACzB,OAAyB;IAEzB,IAAI,IAAI,CAAC,OAAO,KAAK,CAAC;QAAE,OAAO,KAAK,CAAC;IAErC,MAAM,KAAK,GAAG,OAAO,CAAC,IAAI,CACxB,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,GAAG,KAAK,IAAI,CAAC,SAAS,IAAI,CAAC,CAAC,EAAE,KAAK,QAAQ,CACrD,CAAC;IACF,IAAI,CAAC,KAAK;QAAE,OAAO,KAAK,CAAC;IAEzB,oBAAoB;IACpB,IAAI,KAAK,CAAC,MAAM,KAAK,IAAI,CAAC,MAAM;QAAE,OAAO,KAAK,CAAC;IAC/C,IAAI,KAAK,CAAC,QAAQ,KAAK,IAAI,CAAC,WAAW;QAAE,OAAO,KAAK,CAAC;IACtD,IAAI,KAAK,CAAC,SAAS,KAAK,IAAI,CAAC,SAAS;QAAE,OAAO,KAAK,CAAC;IACrD,IAAI,KAAK,CAAC,QAAQ,KAAK,IAAI,CAAC,QAAQ;QAAE,OAAO,KAAK,CAAC;IACnD,IAAI,KAAK,CAAC,EAAE,KAAK,IAAI,CAAC,SAAS;QAAE,OAAO,KAAK,CAAC;IAE9C,kEAAkE;IAClE,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,GAAG,KAAK,IAAI,CAAC,SAAS,GAAG,CAAC,CAAC,CAAC;IAC/D,IAAI,IAAI,IAAI,IAAI,CAAC,SAAS,KAAK,IAAI,CAAC,QAAQ;QAAE,OAAO,KAAK,CAAC;IAC3D,mEAAmE;IACnE,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,SAAS,KAAK,CAAC;QAAE,OAAO,KAAK,CAAC;IAEhD,OAAO,IAAI,CAAC;AACd,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,WAAW,CAAC,OAAe;IACzC,OAAO,UAAU,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;AACpE,CAAC"}

memos/_js/provenance.d.ts

@@ -0,0 +1,122 @@
+/**
+ * Provenance-tiered trust for MemOS — the provenance-trust security layer.
+ *
+ * 2026 is the year memory became the attack surface (InjecMEM/COLM 2026:
+ * one ordinary interaction poisons memory with 35.6% end-to-end success;
+ * Trojan Hippo: dormant payloads persist through 100 benign sessions;
+ * AgentPoison >80% ASR at <0.1% poison rate; ClawHavoc poisoned AI skill
+ * packages). A local-first memory store should know *where* each memory
+ * came from and treat channels unequally — so every memory carries a
+ * provenance tier, assigned at write time and fused into recall scoring.
+ *
+ * Tier ordering (highest trust first):
+ *
+ * - `user-verified` — explicitly confirmed by the user (never assigned
+ *   automatically — only via an explicit `provenance` opt or `verify()`).
+ * - `user`          — ordinary user statements (the default for direct
+ *   `store()` writes, which carry `source: "user_input"`).
+ * - `tool-output`   — results returned by tools (`source: "tool_output"`).
+ * - `chat`          — model-generated content (`source: "agent_inferred"`
+ *   or `source: "system"`).
+ * - `imported`      — bulk imports from ChatGPT/Claude/Slack exports
+ *   (`source: "external_data"`).
+ *
+ * Default rule (documented here and in docs/provenance-trust.md): when
+ * `store()` is called without an explicit `provenance`, the tier is
+ * derived from `source` via {@link defaultProvenanceForSource}.
+ * `user-verified` is the only tier that can never be assigned by the
+ * default rule — it requires an explicit user confirmation step.
+ *
+ * Everything here is dependency-free and LLM-free: tier assignment and
+ * trust fusion are pure local computation, safe for the hot path.
+ *
+ * @module @mem-os/provenance
+ */
+import type { MemoryNode, MemorySource, ProvenanceTier, ScoredMemory } from "./types.js";
+/**
+ * Canonical tier ordering, highest trust first. The index is the
+ * authority for "higher tier wins" comparisons.
+ */
+export declare const PROVENANCE_TIER_ORDER: readonly ProvenanceTier[];
+/**
+ * Tiers whose content a host agent should confirm before acting on,
+ * rather than silently injecting as context. Quarantined-then-released
+ * memories are untrusted regardless of tier (see
+ * {@link isUntrustedForAgent}).
+ */
+export declare const LOW_TRUST_TIERS: ReadonlySet<ProvenanceTier>;
+/**
+ * Per-tier trust multiplier fused into retrieval scoring (see
+ * `fuseResults` in src/retrieval.ts). Deliberately gentle: the top tier
+ * is untouched and the bottom tier keeps 72% of its relevance score, so
+ * provenance nudges ranking without overriding relevance.
+ */
+export declare const PROVENANCE_TRUST: Record<ProvenanceTier, number>;
+/**
+ * Default strength of the provenance multiplier in score fusion
+ * (`score *= 1 - strength * (1 - tierTrust)`). 0.5 keeps the maximum
+ * penalty (imported tier) at ~14% — measurable but never dominant.
+ * Override per deployment via `config.fusion.provenanceWeightStrength`
+ * (0 disables it).
+ */
+export declare const DEFAULT_PROVENANCE_WEIGHT_STRENGTH = 0.5;
+/** Metadata key stamped on a memory released from quarantine. */
+export declare const QUARANTINE_RELEASED_METADATA_KEY = "releasedFromQuarantine";
+/** Runtime guard for the tier union (storage rows may predate the column). */
+export declare function isProvenanceTier(value: unknown): value is ProvenanceTier;
+/**
+ * Default provenance tier for a write, derived from its `source`.
+ *
+ * - `user_input`    → `user` (ordinary user statements)
+ * - `tool_output`   → `tool-output`
+ * - `agent_inferred`→ `chat` (model-generated)
+ * - `system`        → `chat` (machine-generated)
+ * - `external_data` → `imported` (bulk imports)
+ *
+ * `user-verified` is never returned here: explicit user confirmation is
+ * the only path to the top tier.
+ */
+export declare function defaultProvenanceForSource(source: MemorySource): ProvenanceTier;
+/**
+ * Resolve the provenance tier for a write: an explicit, valid
+ * `provenance` option always wins; otherwise the source-derived
+ * default applies.
+ */
+export declare function resolveProvenance(opts: {
+    provenance?: ProvenanceTier;
+    source: MemorySource;
+}): ProvenanceTier;
+/** Compare two tiers: negative when `a` outranks `b`. */
+export declare function compareProvenanceTier(a: ProvenanceTier, b: ProvenanceTier): number;
+/**
+ * Whether a memory's provenance channel is low-trust for agent
+ * consumption: tier `imported` / `tool-output`, or a memory that was
+ * quarantined and later released (its tier alone no longer tells the
+ * story — the release marker does).
+ */
+export declare function isUntrustedForAgent(node: Pick<MemoryNode, "provenance" | "quarantined" | "metadata">): boolean;
+/**
+ * Quarantine visibility for a recall filter. Storage excludes
+ * quarantined rows by default (`includeQuarantined` unset or false);
+ * `includeQuarantined: true` shows everything; `quarantinedOnly: true`
+ * shows only quarantined rows (the review queue).
+ */
+export declare function quarantineVisible(quarantined: boolean, filter: {
+    includeQuarantined?: boolean;
+    quarantinedOnly?: boolean;
+}): boolean;
+/**
+ * The trust multiplier for one tier at a given fusion strength:
+ * `1 - strength * (1 - tierTrust)`. Uniform across a result set, so a
+ * same-tier corpus (e.g. the retrieval eval's all-`user` facts) keeps
+ * byte-identical ranking — the weight is provably neutral there.
+ */
+export declare function provenanceMultiplier(tier: ProvenanceTier, strength?: number): number;
+/**
+ * Stamp trust flags onto search results headed for an agent: the
+ * provenance tier, a citable `[mem:hex]` token tracing the memory to
+ * its source episode, and `untrustedSource` for low-trust channels.
+ * Pure — returns new result objects, never mutates the input.
+ */
+export declare function decorateTrustFlags(results: ScoredMemory[]): ScoredMemory[];
+//# sourceMappingURL=provenance.d.ts.map

memos/_js/provenance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provenance.d.ts","sourceRoot":"","sources":["../src/provenance.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAGH,OAAO,KAAK,EACV,UAAU,EACV,YAAY,EACZ,cAAc,EACd,YAAY,EACb,MAAM,YAAY,CAAC;AAEpB;;;GAGG;AACH,eAAO,MAAM,qBAAqB,EAAE,SAAS,cAAc,EAMjD,CAAC;AAEX;;;;;GAKG;AACH,eAAO,MAAM,eAAe,EAAE,WAAW,CAAC,cAAc,CAGtD,CAAC;AAEH;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB,EAAE,MAAM,CAAC,cAAc,EAAE,MAAM,CAM3D,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,kCAAkC,MAAM,CAAC;AAEtD,iEAAiE;AACjE,eAAO,MAAM,gCAAgC,2BAA2B,CAAC;AAEzE,8EAA8E;AAC9E,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,cAAc,CAKxE;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,0BAA0B,CACxC,MAAM,EAAE,YAAY,GACnB,cAAc,CAahB;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE;IACtC,UAAU,CAAC,EAAE,cAAc,CAAC;IAC5B,MAAM,EAAE,YAAY,CAAC;CACtB,GAAG,cAAc,CAKjB;AAED,yDAAyD;AACzD,wBAAgB,qBAAqB,CACnC,CAAC,EAAE,cAAc,EACjB,CAAC,EAAE,cAAc,GAChB,MAAM,CAER;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,IAAI,CAAC,UAAU,EAAE,YAAY,GAAG,aAAa,GAAG,UAAU,CAAC,GAChE,OAAO,CAYT;AAMD;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAC/B,WAAW,EAAE,OAAO,EACpB,MAAM,EAAE;IAAE,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAAC,eAAe,CAAC,EAAE,OAAO,CAAA;CAAE,GAClE,OAAO,CAIT;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,cAAc,EACpB,QAAQ,GAAE,MAA2C,GACpD,MAAM,CAGR;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,YAAY,EAAE,GAAG,YAAY,EAAE,CAO1E"}

memos/_js/provenance.js

@@ -0,0 +1,182 @@
+/**
+ * Provenance-tiered trust for MemOS — the provenance-trust security layer.
+ *
+ * 2026 is the year memory became the attack surface (InjecMEM/COLM 2026:
+ * one ordinary interaction poisons memory with 35.6% end-to-end success;
+ * Trojan Hippo: dormant payloads persist through 100 benign sessions;
+ * AgentPoison >80% ASR at <0.1% poison rate; ClawHavoc poisoned AI skill
+ * packages). A local-first memory store should know *where* each memory
+ * came from and treat channels unequally — so every memory carries a
+ * provenance tier, assigned at write time and fused into recall scoring.
+ *
+ * Tier ordering (highest trust first):
+ *
+ * - `user-verified` — explicitly confirmed by the user (never assigned
+ *   automatically — only via an explicit `provenance` opt or `verify()`).
+ * - `user`          — ordinary user statements (the default for direct
+ *   `store()` writes, which carry `source: "user_input"`).
+ * - `tool-output`   — results returned by tools (`source: "tool_output"`).
+ * - `chat`          — model-generated content (`source: "agent_inferred"`
+ *   or `source: "system"`).
+ * - `imported`      — bulk imports from ChatGPT/Claude/Slack exports
+ *   (`source: "external_data"`).
+ *
+ * Default rule (documented here and in docs/provenance-trust.md): when
+ * `store()` is called without an explicit `provenance`, the tier is
+ * derived from `source` via {@link defaultProvenanceForSource}.
+ * `user-verified` is the only tier that can never be assigned by the
+ * default rule — it requires an explicit user confirmation step.
+ *
+ * Everything here is dependency-free and LLM-free: tier assignment and
+ * trust fusion are pure local computation, safe for the hot path.
+ *
+ * @module @mem-os/provenance
+ */
+import { citationToken } from "./citations.js";
+/**
+ * Canonical tier ordering, highest trust first. The index is the
+ * authority for "higher tier wins" comparisons.
+ */
+export const PROVENANCE_TIER_ORDER = [
+    "user-verified",
+    "user",
+    "tool-output",
+    "chat",
+    "imported",
+];
+/**
+ * Tiers whose content a host agent should confirm before acting on,
+ * rather than silently injecting as context. Quarantined-then-released
+ * memories are untrusted regardless of tier (see
+ * {@link isUntrustedForAgent}).
+ */
+export const LOW_TRUST_TIERS = new Set([
+    "tool-output",
+    "imported",
+]);
+/**
+ * Per-tier trust multiplier fused into retrieval scoring (see
+ * `fuseResults` in src/retrieval.ts). Deliberately gentle: the top tier
+ * is untouched and the bottom tier keeps 72% of its relevance score, so
+ * provenance nudges ranking without overriding relevance.
+ */
+export const PROVENANCE_TRUST = {
+    "user-verified": 1.0,
+    user: 0.97,
+    "tool-output": 0.9,
+    chat: 0.82,
+    imported: 0.72,
+};
+/**
+ * Default strength of the provenance multiplier in score fusion
+ * (`score *= 1 - strength * (1 - tierTrust)`). 0.5 keeps the maximum
+ * penalty (imported tier) at ~14% — measurable but never dominant.
+ * Override per deployment via `config.fusion.provenanceWeightStrength`
+ * (0 disables it).
+ */
+export const DEFAULT_PROVENANCE_WEIGHT_STRENGTH = 0.5;
+/** Metadata key stamped on a memory released from quarantine. */
+export const QUARANTINE_RELEASED_METADATA_KEY = "releasedFromQuarantine";
+/** Runtime guard for the tier union (storage rows may predate the column). */
+export function isProvenanceTier(value) {
+    return (typeof value === "string" &&
+        PROVENANCE_TIER_ORDER.includes(value));
+}
+/**
+ * Default provenance tier for a write, derived from its `source`.
+ *
+ * - `user_input`    → `user` (ordinary user statements)
+ * - `tool_output`   → `tool-output`
+ * - `agent_inferred`→ `chat` (model-generated)
+ * - `system`        → `chat` (machine-generated)
+ * - `external_data` → `imported` (bulk imports)
+ *
+ * `user-verified` is never returned here: explicit user confirmation is
+ * the only path to the top tier.
+ */
+export function defaultProvenanceForSource(source) {
+    switch (source) {
+        case "tool_output":
+            return "tool-output";
+        case "agent_inferred":
+        case "system":
+            return "chat";
+        case "external_data":
+            return "imported";
+        case "user_input":
+        default:
+            return "user";
+    }
+}
+/**
+ * Resolve the provenance tier for a write: an explicit, valid
+ * `provenance` option always wins; otherwise the source-derived
+ * default applies.
+ */
+export function resolveProvenance(opts) {
+    if (opts.provenance && isProvenanceTier(opts.provenance)) {
+        return opts.provenance;
+    }
+    return defaultProvenanceForSource(opts.source);
+}
+/** Compare two tiers: negative when `a` outranks `b`. */
+export function compareProvenanceTier(a, b) {
+    return PROVENANCE_TIER_ORDER.indexOf(a) - PROVENANCE_TIER_ORDER.indexOf(b);
+}
+/**
+ * Whether a memory's provenance channel is low-trust for agent
+ * consumption: tier `imported` / `tool-output`, or a memory that was
+ * quarantined and later released (its tier alone no longer tells the
+ * story — the release marker does).
+ */
+export function isUntrustedForAgent(node) {
+    if (node.quarantined)
+        return true;
+    if (isProvenanceTier(node.provenance) &&
+        LOW_TRUST_TIERS.has(node.provenance)) {
+        return true;
+    }
+    return (isRecord(node.metadata) &&
+        node.metadata[QUARANTINE_RELEASED_METADATA_KEY] === true);
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+ * Quarantine visibility for a recall filter. Storage excludes
+ * quarantined rows by default (`includeQuarantined` unset or false);
+ * `includeQuarantined: true` shows everything; `quarantinedOnly: true`
+ * shows only quarantined rows (the review queue).
+ */
+export function quarantineVisible(quarantined, filter) {
+    if (filter.quarantinedOnly === true)
+        return quarantined;
+    if (filter.includeQuarantined === true)
+        return true;
+    return !quarantined;
+}
+/**
+ * The trust multiplier for one tier at a given fusion strength:
+ * `1 - strength * (1 - tierTrust)`. Uniform across a result set, so a
+ * same-tier corpus (e.g. the retrieval eval's all-`user` facts) keeps
+ * byte-identical ranking — the weight is provably neutral there.
+ */
+export function provenanceMultiplier(tier, strength = DEFAULT_PROVENANCE_WEIGHT_STRENGTH) {
+    const trust = PROVENANCE_TRUST[tier] ?? 1.0;
+    return 1 - strength * (1 - trust);
+}
+/**
+ * Stamp trust flags onto search results headed for an agent: the
+ * provenance tier, a citable `[mem:hex]` token tracing the memory to
+ * its source episode, and `untrustedSource` for low-trust channels.
+ * Pure — returns new result objects, never mutates the input.
+ */
+export function decorateTrustFlags(results) {
+    return results.map((r) => ({
+        ...r,
+        provenance: r.node.provenance,
+        citation: citationToken(r.node.id),
+        untrustedSource: isUntrustedForAgent(r.node),
+    }));
+}
+//# sourceMappingURL=provenance.js.map

memos/_js/provenance.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"provenance.js","sourceRoot":"","sources":["../src/provenance.ts"],"names":[],"mappings":"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"}

memos/_js/quarantine-commands.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Testable CLI command logic for the quarantine review queue.
+ *
+ * The CLI dispatches `memos quarantine list|release` through these
+ * helpers so the output format is asserted in unit tests rather than
+ * through awkward subprocess runs.
+ */
+import type { MemOS } from "./memory.js";
+import type { MemoryNode } from "./types.js";
+/**
+ * Render the quarantine review queue. JSON mode emits the raw nodes;
+ * human mode prints one line per memory: `[mem:hex]`-style short id,
+ * quarantine reason, and the first ~120 chars of content.
+ */
+export declare function formatQuarantineList(nodes: MemoryNode[], json: boolean): string;
+/**
+ * Release a memory from quarantine and render the result. JSON mode
+ * emits the updated node; human mode confirms the release while
+ * reminding the operator that the memory keeps its low-trust marking
+ * for agent consumption.
+ */
+export declare function releaseQuarantined(memos: MemOS, id: string, json: boolean): Promise<string>;
+//# sourceMappingURL=quarantine-commands.d.ts.map

memos/_js/quarantine-commands.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"quarantine-commands.d.ts","sourceRoot":"","sources":["../src/quarantine-commands.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AACzC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAE7C;;;;GAIG;AACH,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,UAAU,EAAE,EACnB,IAAI,EAAE,OAAO,GACZ,MAAM,CAeR;AAED;;;;;GAKG;AACH,wBAAsB,kBAAkB,CACtC,KAAK,EAAE,KAAK,EACZ,EAAE,EAAE,MAAM,EACV,IAAI,EAAE,OAAO,GACZ,OAAO,CAAC,MAAM,CAAC,CASjB"}