peon-mem 1.0.0

package/dist/evaluation.js

@@ -0,0 +1,244 @@
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+export function computeEvaluationReport(input) {
+    const expected = normalizeExpected(input.expectedMemories);
+    const observed = [
+        ...extractObservedItems(input.retrievedText, "retrieved"),
+        ...extractObservedItems(input.injectedText, "injected")
+    ];
+    const matches = matchExpectedToObserved(expected, observed);
+    const matchedExpectedIds = new Set(matches.map((match) => match.expectedId));
+    const matchedObservedKeys = new Set(matches.map((match) => observedKey(match.observedSource, match.observedContent)));
+    return {
+        expectedCount: expected.length,
+        observedItemCount: observed.length,
+        matchedExpectedCount: matchedExpectedIds.size,
+        matchedObservedItemCount: matchedObservedKeys.size,
+        recall: ratio(matchedExpectedIds.size, expected.length),
+        coverage: ratio(matchedObservedKeys.size, observed.length),
+        missingExpectedItems: expected
+            .filter((item) => !matchedExpectedIds.has(item.id))
+            .map((item) => ({ id: item.id, content: item.content })),
+        unexpectedNoisyItems: observed
+            .filter((item) => !matchedObservedKeys.has(observedKey(item.source, item.content)))
+            .map((item) => ({ source: item.source, content: item.content })),
+        matches,
+        costSummary: summarizeCost(input.processingJobs ?? [])
+    };
+}
+export async function evaluatePeonProject(input) {
+    const peonPath = join(input.projectPath, input.memoryDirName ?? ".peon");
+    const expectedMemories = input.expectedMemories ?? (await readExpectedMemories(peonPath));
+    const retrievedText = await readRetrievedProjectText(peonPath);
+    const injectedText = await readOptionalText(join(peonPath, "brain", "injection-preview.md"));
+    const processingJobs = await readProcessingJobs(peonPath);
+    return computeEvaluationReport({
+        expectedMemories,
+        retrievedText,
+        injectedText,
+        processingJobs
+    });
+}
+function normalizeExpected(items) {
+    return items
+        .map((item, index) => {
+        const content = typeof item === "string" ? item : item.content;
+        const id = typeof item === "string" ? `expected-${index + 1}` : item.id ?? `expected-${index + 1}`;
+        return {
+            id,
+            content: content.trim(),
+            tokens: tokenize(content),
+            normalized: normalizeText(content)
+        };
+    })
+        .filter((item) => item.content.length > 0);
+}
+function extractObservedItems(input, source) {
+    const chunks = Array.isArray(input) ? input : input ? [input] : [];
+    return chunks.flatMap((chunk) => chunk
+        .split(/\r?\n/)
+        .map(cleanObservedLine)
+        .filter(isMeaningfulObservedLine)
+        .map((content) => ({
+        source,
+        content,
+        tokens: tokenize(content),
+        normalized: normalizeText(content)
+    })));
+}
+function cleanObservedLine(line) {
+    return line
+        .trim()
+        .replace(/^[-*]\s+/, "")
+        .replace(/^\d+[.)]\s+/, "")
+        .trim();
+}
+function isMeaningfulObservedLine(line) {
+    if (!line)
+        return false;
+    if (/^#+\s*/.test(line))
+        return false;
+    if (/^[A-Z][A-Za-z ]{1,32}:?$/.test(line))
+        return false;
+    return tokenize(line).length > 0;
+}
+function matchExpectedToObserved(expected, observed) {
+    return expected.flatMap((item) => {
+        const best = observed
+            .map((candidate) => ({ candidate, score: matchScore(item, candidate) }))
+            .filter((candidate) => candidate.score >= 0.6)
+            .sort((left, right) => right.score - left.score || sourceRank(left.candidate.source) - sourceRank(right.candidate.source) || left.candidate.content.localeCompare(right.candidate.content))[0];
+        return best
+            ? [
+                {
+                    expectedId: item.id,
+                    expectedContent: item.content,
+                    observedSource: best.candidate.source,
+                    observedContent: best.candidate.content,
+                    score: round4(best.score)
+                }
+            ]
+            : [];
+    });
+}
+function matchScore(expected, observed) {
+    if (!expected.tokens.length || !observed.tokens.length)
+        return 0;
+    if (observed.normalized.includes(expected.normalized) || expected.normalized.includes(observed.normalized))
+        return 1;
+    const observedTokens = new Set(observed.tokens);
+    const hits = expected.tokens.filter((token) => observedTokens.has(token)).length;
+    return hits / expected.tokens.length;
+}
+function summarizeCost(jobs) {
+    const summary = {
+        jobCount: jobs.length,
+        processedJobs: 0,
+        skippedJobs: 0,
+        failedJobs: 0,
+        totalEstimatedTokens: 0,
+        byModel: {}
+    };
+    for (const job of jobs) {
+        const status = job.status ?? "unknown";
+        const tokens = Number.isFinite(job.estimatedTokens) ? Math.max(0, Math.trunc(job.estimatedTokens ?? 0)) : 0;
+        const model = job.model || "unknown";
+        if (status === "processed")
+            summary.processedJobs += 1;
+        if (status === "skipped")
+            summary.skippedJobs += 1;
+        if (status === "failed")
+            summary.failedJobs += 1;
+        summary.totalEstimatedTokens += tokens;
+        summary.byModel[model] ??= { jobCount: 0, estimatedTokens: 0 };
+        summary.byModel[model].jobCount += 1;
+        summary.byModel[model].estimatedTokens += tokens;
+    }
+    return summary;
+}
+async function readExpectedMemories(peonPath) {
+    const candidates = [
+        join(peonPath, "evaluation", "expected-memories.json"),
+        join(peonPath, "expected-memories.json")
+    ];
+    for (const candidate of candidates) {
+        const text = await readOptionalText(candidate);
+        if (!text.trim())
+            continue;
+        const parsed = JSON.parse(text);
+        if (!Array.isArray(parsed))
+            throw new Error(`${candidate} must contain a JSON array.`);
+        return parsed.flatMap((item) => {
+            if (typeof item === "string")
+                return [item];
+            if (isObject(item) && typeof item.content === "string") {
+                return [{ id: typeof item.id === "string" ? item.id : undefined, content: item.content }];
+            }
+            return [];
+        });
+    }
+    return [];
+}
+async function readRetrievedProjectText(peonPath) {
+    const brainPath = join(peonPath, "brain");
+    const markdownFiles = [
+        "project-summary.md",
+        "decisions.md",
+        "preferences.md",
+        "open-questions.md",
+        "artifacts.md",
+        "timeline.md"
+    ];
+    const markdown = await Promise.all(markdownFiles.map((file) => readOptionalText(join(brainPath, file))));
+    const records = await readMemoryRecordContents(join(brainPath, "memories.jsonl"));
+    return [...markdown, records.join("\n")].filter((text) => text.trim().length > 0);
+}
+async function readMemoryRecordContents(path) {
+    const text = await readOptionalText(path);
+    return text
+        .split(/\r?\n/)
+        .filter(Boolean)
+        .flatMap((line) => {
+        const parsed = JSON.parse(line);
+        return isObject(parsed) && typeof parsed.content === "string" ? [parsed.content] : [];
+    });
+}
+async function readProcessingJobs(peonPath) {
+    const jobsPath = join(peonPath, "brain", "processing-jobs.json");
+    const jobsText = await readOptionalText(jobsPath);
+    if (jobsText.trim()) {
+        const parsed = JSON.parse(jobsText);
+        if (Array.isArray(parsed))
+            return parsed.filter(isObject).map(toProcessingJob);
+    }
+    const stateText = await readOptionalText(join(peonPath, "brain", "processing-state.json"));
+    if (!stateText.trim())
+        return [];
+    const state = JSON.parse(stateText);
+    if (!isObject(state) || !state.lastStatus)
+        return [];
+    return [
+        toProcessingJob({
+            status: state.lastStatus,
+            model: state.lastModel,
+            reason: state.lastReason,
+            estimatedTokens: state.lastEstimatedTokens
+        })
+    ];
+}
+function toProcessingJob(value) {
+    return {
+        status: typeof value.status === "string" ? value.status : undefined,
+        model: typeof value.model === "string" ? value.model : undefined,
+        reason: typeof value.reason === "string" ? value.reason : undefined,
+        estimatedTokens: typeof value.estimatedTokens === "number" ? value.estimatedTokens : undefined
+    };
+}
+async function readOptionalText(path) {
+    return readFile(path, "utf8").catch((error) => {
+        if (isObject(error) && error.code === "ENOENT")
+            return "";
+        throw error;
+    });
+}
+function tokenize(value) {
+    return Array.from(new Set(normalizeText(value).split(" ").filter((token) => token.length > 1)));
+}
+function normalizeText(value) {
+    return value.toLowerCase().replace(/[^a-z0-9]+/g, " ").trim().replace(/\s+/g, " ");
+}
+function ratio(numerator, denominator) {
+    return denominator === 0 ? 1 : round4(numerator / denominator);
+}
+function round4(value) {
+    return Math.round(value * 10000) / 10000;
+}
+function sourceRank(source) {
+    return source === "retrieved" ? 0 : 1;
+}
+function observedKey(source, content) {
+    return `${source}\0${content}`;
+}
+function isObject(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}

package/dist/global-extraction.d.ts

@@ -0,0 +1,15 @@
+import type { PeonConfig } from "./config.js";
+import type { MemoryRecord } from "./types.js";
+/**
+ * The AI-judged path that lets global memory actually build up. A blunt type rule
+ * can't tell "the user runs on the NJIT cluster" (global) from "use flash_attention_2
+ * to match this paper" (project-local) — both are `preference`s. So we ask the cheap
+ * consolidation model to pick out ONLY the cross-cutting beliefs.
+ *
+ * Returns a function that takes a project's beliefs and yields concise global facts.
+ * null when AI is off / no key (global then only grows via explicit promotion).
+ */
+export type GlobalExtractor = (records: readonly MemoryRecord[]) => Promise<string[]>;
+export declare function createGlobalExtractor(config: PeonConfig): GlobalExtractor | null;
+/** Tolerant parse of the model's reply into a clean string list. */
+export declare function parseStringArray(content: string): string[];

package/dist/global-extraction.js

@@ -0,0 +1,61 @@
+export function createGlobalExtractor(config) {
+    if (config.aiMode === "off" || !config.openRouterApiKey)
+        return null;
+    return async (records) => {
+        // Send the highest-signal beliefs only — bounds tokens, focuses the model.
+        const candidates = records
+            .filter((r) => r.status === "active" && r.type !== "timeline" && r.type !== "open_question")
+            .sort((a, b) => b.score.importance - a.score.importance)
+            .slice(0, 60);
+        if (candidates.length === 0)
+            return [];
+        const list = candidates.map((r, i) => `${i + 1}. [${r.type}] ${r.content}`).join("\n");
+        const system = "You curate a user's GLOBAL memory — facts true across ALL of their projects, independent of which one they work on. " +
+            "The beliefs below come from working ON one specific software/research project. " +
+            "CRITICAL: that project's OWN internals are NOT global, even when they sound general — exclude its tools, APIs, " +
+            "architecture, modules, data model, config flags, UI, code decisions, and bugs. If a fact describes how the project " +
+            "being analyzed is built or behaves, DROP it. " +
+            "Extract ONLY facts about the USER and their broader environment that would hold in a completely different project: " +
+            "their compute hardware and clusters (names, hostnames, GPUs, scratch paths), OS, external accounts/services, " +
+            "shell/CLI habits and tools they reuse everywhere (rsync, gh, SLURM commands), and durable personal facts. " +
+            "Example KEEP: 'The user runs GPU jobs on the NJIT Wulver cluster via SLURM.' " +
+            "Example DROP (project-internal): 'The daemon exposes a /global/extract endpoint.' " +
+            "Rewrite each as one self-contained sentence with zero project context. " +
+            "Output ONLY a JSON array of strings — no markdown fences, no prose. If nothing qualifies, return []. Max 8 items.";
+        const response = await fetch("https://openrouter.ai/api/v1/chat/completions", {
+            method: "POST",
+            headers: { Authorization: `Bearer ${config.openRouterApiKey}`, "Content-Type": "application/json" },
+            body: JSON.stringify({
+                model: config.processingModel,
+                messages: [
+                    { role: "system", content: system },
+                    { role: "user", content: `Project beliefs:\n${list}\n\nGlobal facts (JSON array):` }
+                ],
+                temperature: 0.1
+            })
+        });
+        if (!response.ok)
+            throw new Error(`global extraction failed with ${response.status}`);
+        const json = (await response.json());
+        return parseStringArray(json.choices?.[0]?.message?.content ?? "");
+    };
+}
+/** Tolerant parse of the model's reply into a clean string list. */
+export function parseStringArray(content) {
+    const text = content.trim();
+    const fenced = text.match(/```(?:json)?\s*([\s\S]*?)\s*```/);
+    const body = fenced ? fenced[1] : text.slice(text.indexOf("["), text.lastIndexOf("]") + 1);
+    try {
+        const parsed = JSON.parse(body || text);
+        if (!Array.isArray(parsed))
+            return [];
+        return parsed
+            .filter((item) => typeof item === "string")
+            .map((item) => item.trim())
+            .filter((item) => item.length > 0)
+            .slice(0, 8);
+    }
+    catch {
+        return [];
+    }
+}

package/dist/global-memory.d.ts

@@ -0,0 +1,43 @@
+import type { MemoryRecord, MemoryRecordInput, MemoryStatus, MemoryType } from "./types.js";
+export interface OpenGlobalMemoryStoreOptions {
+    globalDir?: string;
+}
+export interface ListGlobalMemoryOptions {
+    query?: string;
+    type?: MemoryType;
+    status?: MemoryStatus;
+}
+export interface GlobalMemorySource {
+    kind?: MemoryRecord["source"]["kind"];
+    reason?: string;
+}
+export declare class PeonGlobalMemoryStore {
+    private readonly globalDir;
+    private static readonly defaultGlobalDir;
+    private constructor();
+    static defaultDirectory(): string;
+    static open(options?: OpenGlobalMemoryStoreOptions): Promise<PeonGlobalMemoryStore>;
+    append(input: MemoryRecordInput, source?: GlobalMemorySource): Promise<MemoryRecord>;
+    upsert(input: MemoryRecordInput, source?: GlobalMemorySource): Promise<MemoryRecord>;
+    list(options?: ListGlobalMemoryOptions): Promise<MemoryRecord[]>;
+    search(query: string, options?: Omit<ListGlobalMemoryOptions, "query">): Promise<MemoryRecord[]>;
+    /**
+     * Curate the GLOBAL brain itself: resolve conflicts and merge duplicates across
+     * the shared cross-project memory (global beliefs are the working set here, so
+     * they are NOT treated as protected). Snapshots a backup first. LLM compression
+     * is opt-in via the summarizer. Returns the actions taken.
+     */
+    runBrainPass(options?: {
+        summarize?: import("./brain.js").Summarizer;
+    }): Promise<import("./brain.js").BrainAction[]>;
+    readBrainActions(limit?: number): Promise<Array<{
+        at: string;
+        actions: import("./brain.js").BrainAction[];
+    }>>;
+    private snapshotBackup;
+    importGlobalRecords(records: MemoryRecord[], source?: GlobalMemorySource): Promise<MemoryRecord[]>;
+    private ensureLayout;
+    private recordsPath;
+    private readRecords;
+    private writeRecords;
+}

package/dist/global-memory.js

@@ -0,0 +1,306 @@
+import { randomUUID } from "node:crypto";
+import { appendFile, mkdir, readFile, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+export class PeonGlobalMemoryStore {
+    globalDir;
+    static defaultGlobalDir = join(homedir(), "Library", "Application Support", "Peon", "global");
+    constructor(globalDir) {
+        this.globalDir = globalDir;
+    }
+    static defaultDirectory() {
+        return PeonGlobalMemoryStore.defaultGlobalDir;
+    }
+    static async open(options = {}) {
+        const store = new PeonGlobalMemoryStore(options.globalDir ?? PeonGlobalMemoryStore.defaultDirectory());
+        await store.ensureLayout();
+        return store;
+    }
+    async append(input, source = {}) {
+        const record = createRecord(input, source, { stableId: false });
+        await appendFile(this.recordsPath(), `${JSON.stringify(record)}\n`, "utf8");
+        return record;
+    }
+    async upsert(input, source = {}) {
+        const records = await this.readRecords();
+        const key = memoryKey(input.type, input.content);
+        const existingIndex = records.findIndex((record) => memoryKey(record.type, record.content) === key);
+        if (existingIndex === -1) {
+            const record = createRecord(input, source, { stableId: true });
+            records.push(record);
+            await this.writeRecords(records);
+            return record;
+        }
+        const existing = records[existingIndex];
+        const updated = mergeRecord(existing, input, source);
+        records[existingIndex] = updated;
+        await this.writeRecords(records);
+        return updated;
+    }
+    async list(options = {}) {
+        const terms = searchTerms(options.query);
+        return (await this.readRecords())
+            .filter((record) => record.scope === "global")
+            .filter((record) => (options.type ? record.type === options.type : true))
+            .filter((record) => (options.status ? record.status === options.status : true))
+            .map((record) => ({ record, relevance: memoryRelevance(record, terms) }))
+            .filter(({ relevance }) => terms.length === 0 || relevance > 0)
+            .sort((left, right) => compareRankedRecords(left, right))
+            .map(({ record }) => record);
+    }
+    async search(query, options = {}) {
+        return this.list({ ...options, query });
+    }
+    /**
+     * Curate the GLOBAL brain itself: resolve conflicts and merge duplicates across
+     * the shared cross-project memory (global beliefs are the working set here, so
+     * they are NOT treated as protected). Snapshots a backup first. LLM compression
+     * is opt-in via the summarizer. Returns the actions taken.
+     */
+    async runBrainPass(options = {}) {
+        const { runSleepCycle } = await import("./brain.js");
+        const all = await this.readRecords();
+        if (all.length === 0)
+            return [];
+        const now = new Date().toISOString();
+        await this.snapshotBackup(all);
+        const { records, actions } = await runSleepCycle(all, {
+            now,
+            summarize: options.summarize,
+            protectGlobalScope: false,
+            makeSummaryId: (entity) => stableMemoryId("summary", `global:${entity}`)
+        });
+        if (actions.length === 0)
+            return [];
+        await this.writeRecords(records);
+        await appendFile(join(this.globalDir, "brain-actions.jsonl"), `${JSON.stringify({ at: now, actions })}\n`, "utf8");
+        return actions;
+    }
+    async readBrainActions(limit = 50) {
+        const raw = await readFile(join(this.globalDir, "brain-actions.jsonl"), "utf8").catch(() => "");
+        const rows = raw.split(/\r?\n/).map((l) => l.trim()).filter(Boolean).flatMap((l) => {
+            try {
+                return [JSON.parse(l)];
+            }
+            catch {
+                return [];
+            }
+        });
+        return rows.slice(-limit).reverse();
+    }
+    async snapshotBackup(records) {
+        const dir = join(this.globalDir, "backups");
+        await mkdir(dir, { recursive: true });
+        const stamp = new Date().toISOString().replace(/[:.]/g, "-");
+        await writeFile(join(dir, `memories-${stamp}.jsonl`), records.map((r) => JSON.stringify(r)).join("\n") + "\n", "utf8");
+    }
+    async importGlobalRecords(records, source = {}) {
+        const imported = [];
+        for (const record of records) {
+            if (record.scope !== "global")
+                continue;
+            imported.push(await this.upsert(memoryRecordToInput(record), {
+                kind: source.kind ?? record.source.kind,
+                reason: source.reason ?? record.source.reason
+            }));
+        }
+        return imported;
+    }
+    async ensureLayout() {
+        await mkdir(this.globalDir, { recursive: true });
+        await readFile(this.recordsPath(), "utf8").catch(async () => {
+            await writeFile(this.recordsPath(), "", "utf8");
+        });
+    }
+    recordsPath() {
+        return join(this.globalDir, "memories.jsonl");
+    }
+    async readRecords() {
+        const raw = await readFile(this.recordsPath(), "utf8").catch(() => "");
+        return raw
+            .split(/\r?\n/)
+            .map((line) => line.trim())
+            .filter(Boolean)
+            .flatMap((line) => {
+            try {
+                const value = JSON.parse(line);
+                return isMemoryRecord(value) ? [value] : [];
+            }
+            catch {
+                return [];
+            }
+        });
+    }
+    async writeRecords(records) {
+        await writeFile(this.recordsPath(), records.map((record) => JSON.stringify(record)).join("\n") + (records.length > 0 ? "\n" : ""), "utf8");
+    }
+}
+function createRecord(input, source, options) {
+    const now = new Date().toISOString();
+    const content = input.content.trim();
+    return {
+        id: options.stableId ? stableMemoryId(input.type, content) : `global_${randomUUID()}`,
+        type: input.type,
+        content,
+        normalized: normalizeMemory(content),
+        scope: "global",
+        status: input.status ?? "active",
+        score: scoreMemory(input),
+        source: {
+            kind: source.kind ?? "manual",
+            reason: source.reason
+        },
+        entities: unique(input.entities ?? []),
+        createdAt: now,
+        updatedAt: now
+    };
+}
+function mergeRecord(existing, input, source) {
+    const score = scoreMemory(input);
+    return {
+        ...existing,
+        type: input.type,
+        content: input.content.trim(),
+        normalized: normalizeMemory(input.content),
+        scope: "global",
+        status: input.status ?? existing.status,
+        score: {
+            importance: Math.max(existing.score.importance, score.importance),
+            confidence: Math.max(existing.score.confidence, score.confidence)
+        },
+        source: {
+            kind: source.kind ?? existing.source.kind,
+            reason: source.reason ?? existing.source.reason
+        },
+        entities: unique([...existing.entities, ...(input.entities ?? [])]),
+        updatedAt: new Date().toISOString()
+    };
+}
+function memoryRecordToInput(record) {
+    return {
+        type: record.type,
+        content: record.content,
+        scope: record.scope,
+        importance: record.score.importance,
+        confidence: record.score.confidence,
+        entities: record.entities,
+        status: record.status
+    };
+}
+function scoreMemory(input) {
+    const baseImportance = {
+        summary: 0.75,
+        decision: 0.9,
+        preference: 0.75,
+        open_question: 0.65,
+        artifact: 0.8,
+        timeline: 0.55,
+        fact: 0.7
+    };
+    return {
+        importance: clamp(input.importance ?? baseImportance[input.type] ?? 0.6),
+        confidence: clamp(input.confidence ?? 0.82)
+    };
+}
+function compareRankedRecords(left, right) {
+    if (left.relevance !== right.relevance)
+        return right.relevance - left.relevance;
+    const statusRank = statusWeight(right.record.status) - statusWeight(left.record.status);
+    if (statusRank !== 0)
+        return statusRank;
+    const leftScore = left.record.score.importance + left.record.score.confidence;
+    const rightScore = right.record.score.importance + right.record.score.confidence;
+    if (leftScore !== rightScore)
+        return rightScore - leftScore;
+    return right.record.updatedAt.localeCompare(left.record.updatedAt);
+}
+function statusWeight(status) {
+    if (status === "active")
+        return 2;
+    if (status === "conflicted")
+        return 1;
+    return 0;
+}
+function memoryRelevance(record, terms) {
+    if (terms.length === 0)
+        return 1;
+    const haystack = `${record.type} ${record.content} ${record.entities.join(" ")}`.toLowerCase();
+    return terms.filter((term) => haystack.includes(term)).length;
+}
+function searchTerms(query) {
+    if (!query)
+        return [];
+    return unique(query
+        .toLowerCase()
+        .split(/[^a-z0-9_.-]+/)
+        .filter((term) => term.length >= 2)
+        .slice(0, 16));
+}
+function memoryKey(type, content) {
+    return `${type}:${normalizeMemory(content)}`;
+}
+function normalizeMemory(content) {
+    return content
+        .toLowerCase()
+        .replace(/[`"'.,;:!?()[\]{}]/g, "")
+        .replace(/\s+/g, " ")
+        .trim();
+}
+function stableMemoryId(type, content) {
+    return `global_${type}_${fnv1a(memoryKey(type, content))}`;
+}
+function fnv1a(value) {
+    let hash = 0x811c9dc5;
+    for (let index = 0; index < value.length; index += 1) {
+        hash ^= value.charCodeAt(index);
+        hash = Math.imul(hash, 0x01000193);
+    }
+    return (hash >>> 0).toString(16).padStart(8, "0");
+}
+function clamp(value) {
+    return Math.max(0, Math.min(1, Number.isFinite(value) ? value : 0));
+}
+function unique(items) {
+    const seen = new Set();
+    return items.filter((item) => {
+        if (seen.has(item))
+            return false;
+        seen.add(item);
+        return true;
+    });
+}
+function isMemoryRecord(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const record = value;
+    return (typeof record.id === "string" &&
+        isMemoryType(record.type) &&
+        typeof record.content === "string" &&
+        typeof record.normalized === "string" &&
+        record.scope === "global" &&
+        isMemoryStatus(record.status) &&
+        typeof record.score?.importance === "number" &&
+        typeof record.score.confidence === "number" &&
+        isMemorySource(record.source) &&
+        Array.isArray(record.entities) &&
+        typeof record.createdAt === "string" &&
+        typeof record.updatedAt === "string");
+}
+function isMemoryType(value) {
+    return (value === "summary" ||
+        value === "decision" ||
+        value === "preference" ||
+        value === "open_question" ||
+        value === "artifact" ||
+        value === "timeline" ||
+        value === "fact");
+}
+function isMemoryStatus(value) {
+    return value === "active" || value === "stale" || value === "conflicted" || value === "superseded" || value === "archived";
+}
+function isMemorySource(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const source = value;
+    return source.kind === "ai_processing" || source.kind === "manual" || source.kind === "hook";
+}