@lanonasis/recall-forge 1.1.1

package/dist/hooks/capture.js

@@ -0,0 +1,162 @@
+import { detectMemoryType } from "../enrichment/type-detector.js";
+import { extractTags } from "../enrichment/tag-extractor.js";
+import { shouldCapture } from "../enrichment/capture-filter.js";
+// Extract text content from message (handles string and content blocks)
+function extractMessageText(msg) {
+    const texts = [];
+    const content = msg.content;
+    if (typeof content === "string") {
+        texts.push(content);
+    }
+    else if (Array.isArray(content)) {
+        for (const block of content) {
+            const b = block;
+            if (b.type === "text" && typeof b.text === "string") {
+                texts.push(b.text);
+            }
+        }
+    }
+    return texts;
+}
+// Build embedding profile metadata when config has explicit profile info
+function embeddingProfileMeta(cfg) {
+    const meta = {};
+    if (cfg.embeddingProfileId)
+        meta.embedding_profile_id = cfg.embeddingProfileId;
+    if (cfg.embeddingProvider)
+        meta.embedding_provider = cfg.embeddingProvider;
+    if (cfg.embeddingModel)
+        meta.embedding_model = cfg.embeddingModel;
+    if (cfg.embeddingDimensions > 0)
+        meta.embedding_dimensions = cfg.embeddingDimensions;
+    return meta;
+}
+// Types that should be routed to shared namespace when configured
+const SHARED_TYPES = new Set(["knowledge", "project", "reference"]);
+// Create memory with proper metadata (Phase 2: shared namespace routing)
+function createMemoryParams(text, cfg, channel, guard) {
+    const guardResult = guard ? guard.process(text) : { content: text, report: null };
+    const safeContent = guardResult.content;
+    const type = detectMemoryType(safeContent);
+    const baseTags = extractTags(safeContent);
+    const privacyTags = guardResult.report && guard ? guard.tagsFrom(guardResult.report) : [];
+    const tags = [...new Set([...baseTags, ...privacyTags])];
+    const title = safeContent.slice(0, 80).replace(/\s+/g, " ").trim();
+    // Route knowledge/project/reference to shared namespace when configured
+    const isShared = cfg.sharedNamespace && SHARED_TYPES.has(type);
+    const privacyMeta = guardResult.report && guard ? guard.metaFrom(guardResult.report) : undefined;
+    return {
+        safeContent,
+        params: {
+            title,
+            content: safeContent,
+            type,
+            tags,
+            metadata: {
+                agent_id: cfg.agentId,
+                source: "openclaw",
+                channel,
+                captured_at: new Date().toISOString(),
+                ...(isShared ? { namespace: cfg.sharedNamespace } : {}),
+                ...embeddingProfileMeta(cfg),
+                ...privacyMeta,
+            },
+        },
+    };
+}
+export function createCaptureHook(client, cfg, logger, fallback, guard, privacyLog) {
+    return async (event) => {
+        try {
+            // 1. Skip if session failed
+            if (!event.success)
+                return;
+            // 2. Determine mode and cap
+            const strict = cfg.captureMode === "hybrid";
+            const cap = cfg.captureMode === "hybrid" ? 3 : 5;
+            // 3. Extract user messages only
+            const userTexts = [];
+            for (const msg of event.messages) {
+                if (!msg || typeof msg !== "object")
+                    continue;
+                const m = msg;
+                if (m.role !== "user")
+                    continue;
+                const texts = extractMessageText(m);
+                userTexts.push(...texts);
+            }
+            // 4. Filter with shouldCapture
+            const toCapture = userTexts.filter((text) => shouldCapture(text, { strict }));
+            // 5. Cap and create memories
+            const captured = toCapture.slice(0, cap);
+            const channel = cfg.defaultChannel;
+            const safeCaptured = [];
+            for (const text of captured) {
+                const { params, safeContent } = createMemoryParams(text, cfg, channel, guard);
+                safeCaptured.push(safeContent);
+                await client.createMemory(params);
+                if (privacyLog && params.metadata?.privacy) {
+                    // Extract the report from metadata for logging — reconstruct minimal shape
+                    const p = params.metadata.privacy;
+                    await privacyLog.write({
+                        secretsFound: p.secretsFound ?? 0,
+                        secretTypes: p.secretTypes ?? [],
+                        piiFound: !!(p.piiTypes),
+                        piiTypes: p.piiTypes ?? [],
+                        piiSensitivity: p.piiSensitivity ?? "none",
+                        regulations: p.regulations ?? [],
+                        action: p.action,
+                        timestamp: p.timestamp,
+                    });
+                }
+            }
+            // 6. Local fallback (single append — uses already-sanitized content)
+            if (cfg.localFallback && safeCaptured.length > 0) {
+                const combined = safeCaptured.join("\n\n---\n\n");
+                await fallback.writeMemory(`Captured ${safeCaptured.length} memories`, combined);
+            }
+        }
+        catch (err) {
+            logger.warn(`capture-hook error: ${err instanceof Error ? err.message : "unknown"}`);
+        }
+    };
+}
+export function createCompactionCaptureHook(client, cfg, logger, guard) {
+    return async (event) => {
+        try {
+            // 1. Extract messages (from event or sessionFile)
+            let messages = event.messages || [];
+            // 2. Filter user messages with strict bar
+            const userTexts = [];
+            for (const msg of messages) {
+                if (!msg || typeof msg !== "object")
+                    continue;
+                const m = msg;
+                if (m.role !== "user")
+                    continue;
+                const texts = extractMessageText(m);
+                userTexts.push(...texts);
+            }
+            // 3. Strict filter + prioritize knowledge/project
+            const filtered = userTexts.filter((text) => shouldCapture(text, { strict: true }));
+            // Prioritize knowledge/project types
+            filtered.sort((a, b) => {
+                const typeA = detectMemoryType(a);
+                const typeB = detectMemoryType(b);
+                const scoreA = typeA === "knowledge" || typeA === "project" ? 1 : 0;
+                const scoreB = typeB === "knowledge" || typeB === "project" ? 1 : 0;
+                return scoreB - scoreA;
+            });
+            // 4. Cap at 3
+            const toCapture = filtered.slice(0, 3);
+            const channel = cfg.defaultChannel;
+            // 5. Create memories
+            for (const text of toCapture) {
+                const { params } = createMemoryParams(text, cfg, channel, guard);
+                await client.createMemory(params);
+            }
+        }
+        catch (err) {
+            logger.warn(`compaction-hook error: ${err instanceof Error ? err.message : "unknown"}`);
+        }
+    };
+}

package/dist/hooks/context-engine.d.ts

@@ -0,0 +1,4 @@
+import type { ContextEngineProvider } from "../plugin-sdk-stub.js";
+import type { LanonasisClient } from "../client.js";
+import type { LanonasisConfig } from "../config.js";
+export declare function createContextEngine(client: LanonasisClient, cfg: LanonasisConfig): ContextEngineProvider;

package/dist/hooks/context-engine.js

@@ -0,0 +1,54 @@
+// RecallForge — contextEngine slot implementation
+// OpenClaw calls buildContext() on demand (not just at session start).
+// This fills plugins.slots.contextEngine, the slot LinkMind currently occupies.
+// Reuses the tieredSearch + prompt-safety machinery from recall.ts.
+import { tieredSearch } from "./recall.js";
+import { looksLikePromptInjection, formatRecalledMemories, } from "../enrichment/prompt-safety.js";
+export function createContextEngine(client, cfg) {
+    return {
+        id: "recall-forge",
+        // Priority 10 — runs before lower-priority engines, yields to explicit user context
+        priority: 10,
+        async buildContext(session) {
+            try {
+                const raw = (session.currentInput ?? session.query ?? "").trim();
+                if (!raw || raw.length < 5)
+                    return "";
+                // Normalise query: strip punctuation-only lines, cap at 200 chars
+                const query = raw
+                    .split("\n")
+                    .filter((l) => /\w/.test(l))
+                    .join(" ")
+                    .slice(0, 200)
+                    .trim() || raw.slice(0, 200);
+                // 5s timeout — never block the agent
+                const memories = await Promise.race([
+                    tieredSearch(client, cfg, query),
+                    new Promise((_, reject) => setTimeout(() => reject(new Error("recall-forge context timeout")), 5000)),
+                ]);
+                if (!memories || memories.length === 0)
+                    return "";
+                // Filter prompt injection attempts before injecting into context window
+                const filtered = memories.filter((m) => !looksLikePromptInjection(m.content));
+                if (filtered.length === 0)
+                    return "";
+                const entries = filtered.map((m) => ({
+                    title: m.title,
+                    type: m.type,
+                    content: m.content,
+                    similarity: m.similarity,
+                    id: m.id,
+                    tags: m.tags,
+                }));
+                return formatRecalledMemories(entries, {
+                    recallStrategy: "semantic",
+                    maxChars: cfg.maxRecallChars,
+                });
+            }
+            catch {
+                // Never throw — a failed context engine must not break the agent session
+                return "";
+            }
+        },
+    };
+}

package/dist/hooks/local-fallback.d.ts

@@ -0,0 +1,5 @@
+export declare class LocalFallbackWriter {
+    private resolvePath;
+    constructor(resolvePath: (p: string) => string);
+    writeMemory(title: string, content: string): Promise<void>;
+}

package/dist/hooks/local-fallback.js

@@ -0,0 +1,31 @@
+// Phase 4 - Local Fallback
+// Note: content passed to writeMemory() should already be sanitized by PrivacyGuard.
+// redactSecrets() runs here as a last-resort belt-and-suspenders defense.
+import { promises as fs } from "fs";
+import { join } from "path";
+import { redactSecrets } from "../extraction/secret-redactor.js";
+export class LocalFallbackWriter {
+    resolvePath;
+    constructor(resolvePath) {
+        this.resolvePath = resolvePath;
+    }
+    async writeMemory(title, content) {
+        try {
+            // Last-resort: strip any credentials that slipped past the guard
+            const { text: safeContent } = redactSecrets(content);
+            // Target: <workspace>/memory/YYYY-MM-DD.md
+            const today = new Date().toISOString().slice(0, 10);
+            const filePath = this.resolvePath(join("memory", `${today}.md`));
+            // Ensure directory exists
+            const dir = filePath.substring(0, filePath.lastIndexOf("/"));
+            await fs.mkdir(dir, { recursive: true });
+            // Format: "## {title}\n\n{content.slice(0, 1000)}\n\n---\n"
+            const formatted = `## ${title}\n\n${safeContent.slice(0, 1000)}\n\n---\n`;
+            // Append mode
+            await fs.appendFile(filePath, formatted, "utf-8");
+        }
+        catch (_err) {
+            // Silently catch all errors - never throws
+        }
+    }
+}

package/dist/hooks/recall.d.ts

@@ -0,0 +1,21 @@
+import type { LanonasisClient, LanMemory } from "../client.js";
+import type { LanonasisConfig } from "../config.js";
+/**
+ * Phase 2: Tiered recall with explicit fallback order.
+ *
+ * 1. Personal — search scoped to this agent's agentId
+ * 2. Shared — search scoped to sharedNamespace (if configured)
+ * 3. Deduplicate across tiers (by memory id)
+ * 4. Cap to maxRecallResults
+ *
+ * If sharedNamespace is empty, recall behaves as before (single unscoped search).
+ */
+export declare function tieredSearch(client: LanonasisClient, cfg: LanonasisConfig, query: string): Promise<(LanMemory & {
+    _recallSource: string;
+})[]>;
+export declare function createRecallHook(client: LanonasisClient, cfg: LanonasisConfig): (event: {
+    prompt: string;
+    messages?: unknown[];
+}) => Promise<{
+    prependContext?: string;
+} | void>;

package/dist/hooks/recall.js

@@ -0,0 +1,123 @@
+import { looksLikePromptInjection, formatRecalledMemories } from "../enrichment/prompt-safety.js";
+/**
+ * Check if a memory's embedding profile matches the current config.
+ * Returns a warning string if mismatched, or undefined if OK.
+ */
+function detectProfileMismatch(memory, cfg) {
+    if (!cfg.embeddingProfileId)
+        return undefined;
+    const storedProfile = memory.metadata?.embedding_profile_id;
+    if (!storedProfile)
+        return undefined;
+    if (storedProfile === cfg.embeddingProfileId)
+        return undefined;
+    return `⚠ profile mismatch: stored=${storedProfile}, query=${cfg.embeddingProfileId}`;
+}
+/** Tag a recalled memory with its source layer for display */
+function tagSource(m, source) {
+    return { ...m, _recallSource: source };
+}
+/**
+ * Phase 2: Tiered recall with explicit fallback order.
+ *
+ * 1. Personal — search scoped to this agent's agentId
+ * 2. Shared — search scoped to sharedNamespace (if configured)
+ * 3. Deduplicate across tiers (by memory id)
+ * 4. Cap to maxRecallResults
+ *
+ * If sharedNamespace is empty, recall behaves as before (single unscoped search).
+ */
+export async function tieredSearch(client, cfg, query) {
+    const baseParams = {
+        query,
+        threshold: cfg.searchThreshold,
+        limit: cfg.maxRecallResults,
+    };
+    // If no shared namespace is configured, do a single unscoped search (backwards compat)
+    if (!cfg.sharedNamespace) {
+        const results = await client.searchMemories(baseParams);
+        return (results ?? []).map((m) => tagSource(m, "personal"));
+    }
+    // Tier 1: Personal recall — scoped to this agent
+    const personalResults = await client.searchMemories({
+        ...baseParams,
+        metadata: { agent_id: cfg.agentId },
+    });
+    // Tier 2: Shared recall — scoped to shared namespace
+    const sharedResults = await client.searchMemories({
+        ...baseParams,
+        metadata: { namespace: cfg.sharedNamespace },
+    });
+    // Deduplicate by id (personal takes priority)
+    const seen = new Set();
+    const merged = [];
+    for (const m of personalResults ?? []) {
+        if (!seen.has(m.id)) {
+            seen.add(m.id);
+            merged.push(tagSource(m, "personal"));
+        }
+    }
+    for (const m of sharedResults ?? []) {
+        if (!seen.has(m.id)) {
+            seen.add(m.id);
+            merged.push(tagSource(m, "shared"));
+        }
+    }
+    // Sort by similarity descending, cap to limit
+    merged.sort((a, b) => (b.similarity ?? 0) - (a.similarity ?? 0));
+    return merged.slice(0, cfg.maxRecallResults);
+}
+export function createRecallHook(client, cfg) {
+    return async (event) => {
+        try {
+            // 1. Skip if prompt too short
+            if (!event.prompt || event.prompt.length < 5) {
+                return undefined;
+            }
+            // 2. Trim query: first 200 chars, drop punctuation-only lines
+            const trimmedQuery = event.prompt
+                .split("\n")
+                .filter((l) => /\w/.test(l))
+                .join(" ")
+                .slice(0, 200)
+                .trim() || event.prompt.slice(0, 200);
+            // 3. Tiered search: personal → shared (5s timeout)
+            const memories = await Promise.race([
+                tieredSearch(client, cfg, trimmedQuery),
+                new Promise((_, reject) => setTimeout(() => reject(new Error("recall timeout")), 5000)),
+            ]);
+            // 4. If 0 results, return void
+            if (!memories || memories.length === 0) {
+                return undefined;
+            }
+            // 5. Filter out prompt injection attempts
+            const filtered = memories.filter((m) => !looksLikePromptInjection(m.content));
+            if (filtered.length === 0) {
+                return undefined;
+            }
+            // 6. Annotate with profile mismatch and source, pass id + tags through
+            const entries = filtered.map((m) => {
+                const mismatch = detectProfileMismatch(m, cfg);
+                const sourceTag = cfg.sharedNamespace ? ` [${m._recallSource}]` : "";
+                return {
+                    title: `${m.title}${sourceTag}`,
+                    type: m.type,
+                    content: mismatch ? `${m.content}\n\n${mismatch}` : m.content,
+                    similarity: m.similarity,
+                    id: m.id,
+                    tags: m.tags,
+                };
+            });
+            // 7. Format and return with strategy hint and char budget
+            const formatted = formatRecalledMemories(entries, {
+                recallStrategy: "semantic",
+                maxChars: cfg.maxRecallChars,
+            });
+            return { prependContext: formatted };
+        }
+        catch (_err) {
+            // Never throw - return void on error
+            return undefined;
+        }
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+import type { OpenClawPlugin } from "./plugin-sdk-stub.js";
+declare const plugin: OpenClawPlugin;
+export default plugin;

package/dist/index.js

@@ -0,0 +1,103 @@
+import { lanonasisConfigSchema } from "./config.js";
+import { LanonasisClient } from "./client.js";
+import { LocalFallbackWriter } from "./hooks/local-fallback.js";
+import { createContextEngine } from "./hooks/context-engine.js";
+import { createCaptureHook, createCompactionCaptureHook } from "./hooks/capture.js";
+import { registerMemorySearchTool } from "./tools/memory-search.js";
+import { registerMemoryGetTool } from "./tools/memory-get.js";
+import { registerMemoryStoreTool } from "./tools/memory-store.js";
+import { registerMemoryForgetTool } from "./tools/memory-forget.js";
+import { registerCli } from "./cli.js";
+import { PrivacyGuard } from "./privacy/privacy-guard.js";
+import { PrivacyLogWriter } from "./privacy/privacy-log.js";
+const CONFIG_PATH = 'plugins.entries["recall-forge"].config';
+function formatErrorMessage(error) {
+    if (error instanceof Error && error.message.trim()) {
+        return error.message;
+    }
+    return typeof error === "string" && error.trim() ? error : "unknown error";
+}
+function missingConfigMessage(field, envName) {
+    return `${field} is required. Set ${CONFIG_PATH}.${field} in ~/.openclaw/openclaw.json or export ${envName} before starting OpenClaw.`;
+}
+const plugin = {
+    id: "recall-forge",
+    kind: "memory",
+    name: "RecallForge",
+    description: "Secret-safe memory and context engine for OpenClaw — semantic recall with credential protection",
+    configSchema: {}, // JSON Schema validation handled by openclaw.plugin.json
+    register(api) {
+        let cachedRuntime;
+        const getRuntime = () => {
+            const cfg = lanonasisConfigSchema.parse(api.pluginConfig);
+            if (!cfg.apiKey) {
+                throw new Error(missingConfigMessage("apiKey", "LANONASIS_API_KEY"));
+            }
+            if (!cfg.projectId) {
+                throw new Error(missingConfigMessage("projectId", "LANONASIS_PROJECT_ID"));
+            }
+            const cacheKey = JSON.stringify([
+                cfg.baseUrl,
+                cfg.apiKey,
+                cfg.projectId,
+                cfg.agentId,
+                cfg.autoRecall,
+                cfg.recallMode,
+                cfg.maxRecallChars,
+                cfg.captureMode,
+                cfg.localFallback,
+                cfg.searchThreshold,
+                cfg.dedupeThreshold,
+                cfg.maxRecallResults,
+                cfg.memoryMode,
+                cfg.sharedNamespace,
+                cfg.embeddingProfileId,
+            ]);
+            if (!cachedRuntime || cachedRuntime.cacheKey !== cacheKey) {
+                cachedRuntime = {
+                    cfg,
+                    client: new LanonasisClient(cfg),
+                    cacheKey,
+                };
+            }
+            return cachedRuntime;
+        };
+        // 1. Always register CLI so subcommands remain visible even if runtime config is incomplete.
+        registerCli(api, getRuntime);
+        // 2. Initialise runtime for hooks and tools.
+        let runtime;
+        try {
+            runtime = getRuntime();
+        }
+        catch (err) {
+            api.logger.error(`[recall-forge] ${formatErrorMessage(err)}`);
+            return;
+        }
+        const { client, cfg } = runtime;
+        // 3. Local fallback writer (writes ~/.openclaw/workspace/memory/YYYY-MM-DD.md)
+        const fallback = new LocalFallbackWriter(api.resolvePath);
+        // 3a. Privacy guard — two-stage pipeline: credential stripping + PII masking
+        //     privacyMode: 'mask' (default) | 'detect' (scan only) | 'off' (credentials only)
+        //     logger passed so webhook failures are surfaced as warnings rather than silently dropped
+        const guard = new PrivacyGuard(cfg, api.logger);
+        const privacyLog = cfg.localFallback ? new PrivacyLogWriter(api.resolvePath) : undefined;
+        // 4. Context engine — fills plugins.slots.contextEngine (active, on-demand)
+        //    OpenClaw calls buildContext() whenever it needs to assemble agent context.
+        //    Secret-redacted tiered recall with prompt injection protection.
+        api.registerContextEngine(createContextEngine(client, cfg));
+        // 5. Capture hooks — auto/hybrid modes only (explicit = agent calls memory_store directly)
+        if (cfg.captureMode !== "explicit") {
+            api.on("agent_end", createCaptureHook(client, cfg, api.logger, fallback, guard, privacyLog));
+            api.on("before_compaction", createCompactionCaptureHook(client, cfg, api.logger, guard));
+        }
+        // 6. Agent tools — always registered regardless of captureMode
+        registerMemorySearchTool(api, client, cfg);
+        registerMemoryGetTool(api, client);
+        registerMemoryStoreTool(api, client, cfg, guard);
+        registerMemoryForgetTool(api, client);
+        const sharedLabel = cfg.sharedNamespace ? `shared: ${cfg.sharedNamespace}` : "shared: off";
+        const recallStatus = cfg.autoRecall && cfg.recallMode !== "ondemand" ? "contextEngine" : cfg.recallMode === "ondemand" ? "ondemand" : "off";
+        api.logger.info(`[recall-forge] Ready — slots: memory+contextEngine | mode: ${cfg.captureMode} | memory: ${cfg.memoryMode} | recall: ${recallStatus} | ${sharedLabel} | fallback: ${cfg.localFallback} | privacy: ${cfg.privacyMode} | project: ${cfg.projectId}`);
+    },
+};
+export default plugin;

package/dist/plugin-sdk-stub.d.ts

@@ -0,0 +1,53 @@
+/**
+ * The session object passed to contextEngine.buildContext().
+ * OpenClaw populates this with the current agent session state.
+ */
+export type OpenClawSession = {
+    /** The user's current input or prompt being assembled */
+    currentInput?: string;
+    /** Alias for currentInput — some OpenClaw versions use this field */
+    query?: string;
+    /** Prior turns in the current session */
+    history?: unknown[];
+    /** Arbitrary session metadata provided by OpenClaw */
+    metadata?: Record<string, unknown>;
+};
+/**
+ * A context engine provider — registered via api.registerContextEngine().
+ * OpenClaw calls buildContext() on demand to inject context into the prompt window.
+ * This is a separate slot from memory (plugins.slots.contextEngine).
+ */
+export type ContextEngineProvider = {
+    id: string;
+    /** Higher priority runs first when multiple contextEngines are registered */
+    priority?: number;
+    /** Return a formatted string to prepend to the agent context window */
+    buildContext: (session: OpenClawSession) => Promise<string>;
+};
+export type OpenClawPluginApi = {
+    pluginConfig: unknown;
+    resolvePath: (path: string) => string;
+    logger: {
+        info: (msg: string) => void;
+        warn: (msg: string) => void;
+        error: (msg: string) => void;
+    };
+    on: (event: string, handler: Function) => void;
+    registerTool: (tool: any, opts?: any) => void;
+    registerCli: (handler: Function, opts: any) => void;
+    registerService: (service: any) => void;
+    /**
+     * Register a context engine provider.
+     * Fills the plugins.slots.contextEngine slot in OpenClaw.
+     * OpenClaw calls buildContext() whenever it needs to assemble agent context.
+     */
+    registerContextEngine: (engine: ContextEngineProvider) => void;
+};
+export type OpenClawPlugin = {
+    id: string;
+    kind: string;
+    name?: string;
+    description?: string;
+    configSchema?: any;
+    register: (api: OpenClawPluginApi) => void;
+};

package/dist/plugin-sdk-stub.js

@@ -0,0 +1,3 @@
+// Simple stub for OpenClaw plugin SDK
+// This allows the plugin to compile and load
+export {};

package/dist/privacy/privacy-guard.d.ts

@@ -0,0 +1,33 @@
+import type { LanonasisConfig } from "../config.js";
+export type PrivacyMode = "off" | "detect" | "mask";
+export interface PrivacyReport {
+    secretsFound: number;
+    secretTypes: string[];
+    piiFound: boolean;
+    piiTypes: string[];
+    piiSensitivity: "none" | "low" | "medium" | "high" | "critical";
+    regulations: string[];
+    action: "passthrough" | "redacted" | "masked" | "detected" | "redacted+masked";
+    timestamp: string;
+}
+export interface GuardResult {
+    content: string;
+    report: PrivacyReport;
+}
+export declare class PrivacyGuard {
+    private sdk;
+    private mode;
+    private locale;
+    private notifyUrl;
+    private logger?;
+    constructor(cfg: LanonasisConfig, logger?: {
+        warn(msg: string): void;
+    });
+    process(content: string): GuardResult;
+    /** Tags to merge into memory tags based on what was found */
+    tagsFrom(report: PrivacyReport): string[];
+    /** Metadata to merge into memory.metadata — omitted entirely if passthrough */
+    metaFrom(report: PrivacyReport): Record<string, unknown> | undefined;
+    /** Fire-and-forget webhook — never blocks the write path, never throws */
+    private notify;
+}