@unblocklabs/unblock-memory 0.1.1

package/dist/src/plugin.js

@@ -0,0 +1,325 @@
+import { Type } from "typebox";
+import { jsonResult, readStringParam } from "openclaw/plugin-sdk/agent-runtime";
+import { resolveConfig } from "./config.js";
+import { QmdMemoryRuntime } from "./runtime.js";
+function getContext(ctx) {
+    const cfg = ctx.getRuntimeConfig?.() ?? ctx.runtimeConfig ?? ctx.config;
+    if (!cfg || !ctx.agentId)
+        return undefined;
+    return { cfg, agentId: ctx.agentId };
+}
+function toolParams(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value)
+        ? Object.fromEntries(Object.entries(value))
+        : {};
+}
+function createSearchTool(runtime, ctx) {
+    const active = getContext(ctx);
+    if (!active)
+        return null;
+    return {
+        name: "memory_search",
+        label: "Memory Search",
+        description: "Search canonical Markdown memory with semantic vector retrieval.",
+        parameters: Type.Object({
+            query: Type.String(),
+            maxResults: Type.Optional(Type.Integer({ minimum: 1, maximum: 20 })),
+            minScore: Type.Optional(Type.Number({ minimum: 0, maximum: 1 })),
+        }),
+        async execute(_toolCallId, params, signal) {
+            const raw = toolParams(params);
+            const query = readStringParam(raw, "query");
+            if (!query)
+                throw new Error("query is required");
+            const maxResults = typeof raw.maxResults === "number" ? raw.maxResults : undefined;
+            const minScore = typeof raw.minScore === "number" ? raw.minScore : undefined;
+            const { manager, error } = await runtime.getMemorySearchManager(active);
+            if (!manager)
+                return jsonResult({ results: [], error: error ?? "memory unavailable" });
+            const results = await manager.search(query, { maxResults, minScore, signal });
+            return jsonResult({ results, provider: "unblock-memory" });
+        },
+    };
+}
+function createGetTool(runtime, ctx) {
+    const active = getContext(ctx);
+    if (!active)
+        return null;
+    return {
+        name: "memory_get",
+        label: "Memory Get",
+        description: "Read an exact qmd:// path returned by memory_search.",
+        parameters: Type.Object({
+            path: Type.String(),
+            from: Type.Optional(Type.Integer({ minimum: 1 })),
+            lines: Type.Optional(Type.Integer({ minimum: 1, maximum: 1000 })),
+        }),
+        async execute(_toolCallId, params) {
+            const raw = toolParams(params);
+            const path = readStringParam(raw, "path");
+            if (!path)
+                throw new Error("path is required");
+            const { manager, error } = await runtime.getMemorySearchManager(active);
+            if (!manager)
+                return jsonResult({ status: "unavailable", error: error ?? "memory unavailable" });
+            return jsonResult(await manager.readFile({
+                relPath: path,
+                from: typeof raw.from === "number" ? raw.from : undefined,
+                lines: typeof raw.lines === "number" ? raw.lines : undefined,
+            }));
+        },
+    };
+}
+const reclusterParameters = Type.Object({
+    space: Type.Optional(Type.Object({
+        method: Type.Optional(Type.Union([Type.Literal("umap"), Type.Literal("none")])),
+        nComponents: Type.Optional(Type.Integer({ minimum: 2, maximum: 100 })),
+        nNeighbors: Type.Optional(Type.Integer({ minimum: 2, maximum: 200 })),
+        minDist: Type.Optional(Type.Number({ minimum: 0, maximum: 1 })),
+    }, { additionalProperties: false })),
+    hdbscan: Type.Optional(Type.Object({
+        minClusterSize: Type.Optional(Type.Integer({ minimum: 2, maximum: 100_000 })),
+        minSamples: Type.Optional(Type.Integer({ minimum: 1, maximum: 100_000 })),
+        clusterSelectionMethod: Type.Optional(Type.Union([Type.Literal("eom"), Type.Literal("leaf")])),
+        clusterSelectionEpsilon: Type.Optional(Type.Number({ minimum: 0 })),
+        allowSingleCluster: Type.Optional(Type.Boolean()),
+    }, { additionalProperties: false })),
+    seed: Type.Optional(Type.Integer({ minimum: 0, maximum: 4_294_967_295 })),
+}, { additionalProperties: false });
+function requireObject(value, name) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw new Error(`${name} must be an object`);
+    }
+    return Object.fromEntries(Object.entries(value));
+}
+function optionalNumber(value, key, constraints) {
+    const candidate = value[key];
+    if (candidate === undefined)
+        return undefined;
+    const valid = typeof candidate === "number" && Number.isFinite(candidate) &&
+        candidate >= constraints.minimum &&
+        (constraints.maximum === undefined || candidate <= constraints.maximum) &&
+        (!constraints.integer || Number.isInteger(candidate));
+    if (!valid)
+        throw new Error(`${key} is invalid`);
+    return candidate;
+}
+function requireOnlyKeys(value, allowed) {
+    const unexpected = Object.keys(value).find((key) => !allowed.includes(key));
+    if (unexpected)
+        throw new Error(`${unexpected} is not allowed`);
+}
+function parseReclusterOptions(params) {
+    const raw = toolParams(params);
+    requireOnlyKeys(raw, ["space", "hdbscan", "seed"]);
+    const options = {};
+    if (raw.space !== undefined) {
+        const space = requireObject(raw.space, "space");
+        requireOnlyKeys(space, ["method", "nComponents", "nNeighbors", "minDist"]);
+        const method = space.method;
+        if (method !== undefined && method !== "umap" && method !== "none") {
+            throw new Error("space.method is invalid");
+        }
+        options.space = {
+            ...(method === undefined ? {} : { method }),
+            ...optionalEntry("nComponents", optionalNumber(space, "nComponents", { minimum: 2, maximum: 100, integer: true })),
+            ...optionalEntry("nNeighbors", optionalNumber(space, "nNeighbors", { minimum: 2, maximum: 200, integer: true })),
+            ...optionalEntry("minDist", optionalNumber(space, "minDist", { minimum: 0, maximum: 1 })),
+        };
+    }
+    if (raw.hdbscan !== undefined) {
+        const hdbscan = requireObject(raw.hdbscan, "hdbscan");
+        requireOnlyKeys(hdbscan, [
+            "minClusterSize",
+            "minSamples",
+            "clusterSelectionMethod",
+            "clusterSelectionEpsilon",
+            "allowSingleCluster",
+        ]);
+        const method = hdbscan.clusterSelectionMethod;
+        if (method !== undefined && method !== "eom" && method !== "leaf") {
+            throw new Error("hdbscan.clusterSelectionMethod is invalid");
+        }
+        const allowSingleCluster = hdbscan.allowSingleCluster;
+        if (allowSingleCluster !== undefined && typeof allowSingleCluster !== "boolean") {
+            throw new Error("hdbscan.allowSingleCluster is invalid");
+        }
+        options.hdbscan = {
+            ...optionalEntry("minClusterSize", optionalNumber(hdbscan, "minClusterSize", { minimum: 2, maximum: 100_000, integer: true })),
+            ...optionalEntry("minSamples", optionalNumber(hdbscan, "minSamples", { minimum: 1, maximum: 100_000, integer: true })),
+            ...(method === undefined ? {} : { clusterSelectionMethod: method }),
+            ...optionalEntry("clusterSelectionEpsilon", optionalNumber(hdbscan, "clusterSelectionEpsilon", { minimum: 0 })),
+            ...(allowSingleCluster === undefined ? {} : { allowSingleCluster }),
+        };
+    }
+    const seed = optionalNumber(raw, "seed", { minimum: 0, maximum: 4_294_967_295, integer: true });
+    if (seed !== undefined)
+        options.seed = seed;
+    return options;
+}
+function optionalEntry(key, value) {
+    return value === undefined ? {} : { [key]: value };
+}
+function createReclusterTool(runtime, ctx) {
+    const active = getContext(ctx);
+    if (!active)
+        return null;
+    return {
+        name: "memory_recluster",
+        label: "Recluster Memory",
+        description: "Rebuild memory clusters from existing QMD vectors. Call only when memory_list_clusters reports missing or stale analysis.",
+        parameters: reclusterParameters,
+        async execute(_toolCallId, params, signal) {
+            const options = parseReclusterOptions(params);
+            const { manager, error } = await runtime.getMemorySearchManager(active);
+            if (!manager)
+                return jsonResult({ status: "unavailable", error: error ?? "memory unavailable" });
+            try {
+                return jsonResult(await manager.recluster(options, signal));
+            }
+            catch (analysisError) {
+                return jsonResult({
+                    status: "unavailable",
+                    error: analysisError instanceof Error ? analysisError.message : String(analysisError),
+                });
+            }
+        },
+    };
+}
+function createListClustersTool(runtime, ctx) {
+    const active = getContext(ctx);
+    if (!active)
+        return null;
+    return {
+        name: "memory_list_clusters",
+        label: "List Memory Clusters",
+        description: "List current memory clusters and freshness. Call this before memory_recluster or memory_fetch_cluster.",
+        parameters: Type.Object({
+            limit: Type.Optional(Type.Integer({ minimum: 1, maximum: 50 })),
+        }, { additionalProperties: false }),
+        async execute(_toolCallId, params) {
+            const raw = toolParams(params);
+            requireOnlyKeys(raw, ["limit"]);
+            const limit = optionalNumber(raw, "limit", { minimum: 1, maximum: 50, integer: true });
+            const { manager, error } = await runtime.getMemorySearchManager(active);
+            if (!manager)
+                return jsonResult({ status: "unavailable", error: error ?? "memory unavailable" });
+            return jsonResult(await manager.listClusters(limit));
+        },
+    };
+}
+function createFetchClusterTool(runtime, ctx) {
+    const active = getContext(ctx);
+    if (!active)
+        return null;
+    return {
+        name: "memory_fetch_cluster",
+        label: "Fetch Memory Cluster",
+        description: "Fetch the top representative QMD chunks for a clusterId returned by memory_list_clusters.",
+        parameters: Type.Object({
+            clusterId: Type.String({ pattern: "^[0-9a-f]{10}$" }),
+            topK: Type.Optional(Type.Integer({ minimum: 1, maximum: 50 })),
+        }, { additionalProperties: false }),
+        async execute(_toolCallId, params) {
+            const raw = toolParams(params);
+            requireOnlyKeys(raw, ["clusterId", "topK"]);
+            const clusterId = readStringParam(raw, "clusterId");
+            if (!clusterId || !/^[0-9a-f]{10}$/.test(clusterId))
+                throw new Error("clusterId is invalid");
+            const topK = optionalNumber(raw, "topK", { minimum: 1, maximum: 50, integer: true });
+            const { manager, error } = await runtime.getMemorySearchManager(active);
+            if (!manager)
+                return jsonResult({ status: "unavailable", error: error ?? "memory unavailable" });
+            return jsonResult(await manager.fetchCluster({ clusterId, topK }));
+        },
+    };
+}
+function formatDateInTimezone(timestamp, timezone) {
+    const parts = new Intl.DateTimeFormat("en-US", {
+        timeZone: timezone,
+        year: "numeric",
+        month: "2-digit",
+        day: "2-digit",
+    }).formatToParts(new Date(timestamp));
+    const part = (type) => parts.find((entry) => entry.type === type)?.value;
+    return `${part("year")}-${part("month")}-${part("day")}`;
+}
+function nonNegativeInteger(value, fallback) {
+    return typeof value === "number" && Number.isFinite(value) && value >= 0
+        ? Math.floor(value)
+        : fallback;
+}
+function parseByteSize(value) {
+    if (typeof value === "number") {
+        const bytes = Math.floor(value);
+        return Number.isSafeInteger(bytes) && bytes >= 0 ? bytes : undefined;
+    }
+    if (typeof value !== "string")
+        return undefined;
+    const match = /^(\d+(?:\.\d+)?)(b|k|kb|m|mb|g|gb|t|tb)?$/i.exec(value.trim());
+    if (!match)
+        return undefined;
+    const unit = (match[2] ?? "b").toLowerCase();
+    const powers = {
+        b: 0,
+        k: 1,
+        kb: 1,
+        m: 2,
+        mb: 2,
+        g: 3,
+        gb: 3,
+        t: 4,
+        tb: 4,
+    };
+    const bytes = Math.round(Number(match[1]) * 1024 ** powers[unit]);
+    return Number.isSafeInteger(bytes) ? bytes : undefined;
+}
+function resolveTimezone(cfg) {
+    const configured = cfg?.agents?.defaults?.userTimezone?.trim();
+    if (configured) {
+        try {
+            new Intl.DateTimeFormat("en-US", { timeZone: configured }).format();
+            return configured;
+        }
+        catch {
+            // Host validation normally prevents this; fall through defensively.
+        }
+    }
+    return Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC";
+}
+export function resolveFlushPlan(params = {}) {
+    const configured = params.cfg?.agents?.defaults?.compaction?.memoryFlush;
+    if (configured?.enabled === false)
+        return null;
+    const nowMs = params.nowMs ?? Date.now();
+    const date = formatDateInTimezone(nowMs, resolveTimezone(params.cfg));
+    const target = `memory/${date}.md`;
+    return {
+        softThresholdTokens: nonNegativeInteger(configured?.softThresholdTokens, 4000),
+        forceFlushTranscriptBytes: parseByteSize(configured?.forceFlushTranscriptBytes) ?? 2 * 1024 * 1024,
+        reserveTokensFloor: 20_000,
+        model: configured?.model?.trim() || undefined,
+        prompt: `Pre-compaction memory flush. Store durable memories only in ${target}. If it exists, append; never overwrite it or bootstrap files. Do not create timestamped variants. If nothing is durable, reply NO_REPLY.`,
+        systemPrompt: `Capture durable memories in ${target}; append only and do not overwrite bootstrap files. Usually NO_REPLY is correct.`,
+        relativePath: target,
+    };
+}
+export function registerUnblockMemory(api) {
+    const config = resolveConfig(api.pluginConfig);
+    const runtime = new QmdMemoryRuntime(config.paths, config.analysis.executable);
+    const capability = {
+        deterministicRecallToolName: "memory_search",
+        supportsPrivateTranscriptRecall: false,
+        promptBuilder: ({ availableTools }) => availableTools.has("memory_search")
+            ? ["Use memory_search for relevant past facts, then memory_get when more surrounding context is needed."]
+            : [],
+        flushPlanResolver: resolveFlushPlan,
+        runtime,
+    };
+    api.registerMemoryCapability(capability);
+    api.registerTool((ctx) => createSearchTool(runtime, ctx), { names: ["memory_search"] });
+    api.registerTool((ctx) => createGetTool(runtime, ctx), { names: ["memory_get"] });
+    api.registerTool((ctx) => createReclusterTool(runtime, ctx), { names: ["memory_recluster"] });
+    api.registerTool((ctx) => createListClustersTool(runtime, ctx), { names: ["memory_list_clusters"] });
+    api.registerTool((ctx) => createFetchClusterTool(runtime, ctx), { names: ["memory_fetch_cluster"] });
+}

package/dist/src/runtime.d.ts

@@ -0,0 +1,24 @@
+import type { OpenClawConfig } from "openclaw/plugin-sdk/plugin-entry";
+import type { MemoryPluginRuntimeContract } from "./contracts.js";
+import { QmdMemoryManager } from "./manager.js";
+export declare class QmdMemoryRuntime implements MemoryPluginRuntimeContract {
+    #private;
+    constructor(paths: readonly string[], analysisExecutable?: string);
+    getMemorySearchManager(params: {
+        cfg: OpenClawConfig;
+        agentId: string;
+    }): Promise<{
+        manager: QmdMemoryManager;
+        error?: undefined;
+    } | {
+        manager: null;
+        error: string;
+    }>;
+    resolveMemoryBackendConfig(): {
+        backend: "builtin";
+    };
+    closeMemorySearchManager(params: {
+        agentId: string;
+    }): Promise<void>;
+    closeAllMemorySearchManagers(): Promise<void>;
+}

package/dist/src/runtime.js

@@ -0,0 +1,51 @@
+import { join } from "node:path";
+import { resolveAgentWorkspaceDir, resolveStateDir, } from "openclaw/plugin-sdk/memory-core-host-engine-foundation";
+import { QmdMemoryManager } from "./manager.js";
+import { resolveSource } from "./sources.js";
+export class QmdMemoryRuntime {
+    #paths;
+    #analysisExecutable;
+    #managers = new Map();
+    constructor(paths, analysisExecutable) {
+        this.#paths = paths;
+        this.#analysisExecutable = analysisExecutable;
+    }
+    async getMemorySearchManager(params) {
+        let pending = this.#managers.get(params.agentId);
+        if (!pending) {
+            pending = this.#createManager(params.cfg, params.agentId);
+            this.#managers.set(params.agentId, pending);
+        }
+        try {
+            return { manager: await pending };
+        }
+        catch (error) {
+            this.#managers.delete(params.agentId);
+            return { manager: null, error: error instanceof Error ? error.message : String(error) };
+        }
+    }
+    resolveMemoryBackendConfig() {
+        return { backend: "builtin" };
+    }
+    async closeMemorySearchManager(params) {
+        const pending = this.#managers.get(params.agentId);
+        this.#managers.delete(params.agentId);
+        await (await pending)?.close();
+    }
+    async closeAllMemorySearchManagers() {
+        const managers = [...this.#managers.values()];
+        this.#managers.clear();
+        await Promise.all(managers.map(async (pending) => (await pending).close()));
+    }
+    async #createManager(cfg, agentId) {
+        const workspaceDir = resolveAgentWorkspaceDir(cfg, agentId);
+        const manager = new QmdMemoryManager({
+            workspaceDir,
+            dbPath: join(resolveStateDir(), "agents", agentId, "unblock-memory", "index.sqlite"),
+            sources: this.#paths.map((source) => resolveSource(workspaceDir, source)),
+            analysisExecutable: this.#analysisExecutable,
+        });
+        await manager.start();
+        return manager;
+    }
+}

package/dist/src/sources.d.ts

@@ -0,0 +1,13 @@
+export type ResolvedSource = {
+    collection: string;
+    configuredPath: string;
+    root: string;
+    pattern: string;
+    watchPath: string;
+};
+export declare function resolveSource(workspaceDir: string, configuredPath: string): ResolvedSource;
+export declare function parseSafeVirtualPath(virtualPath: string, sources: ReadonlyMap<string, ResolvedSource>): {
+    source: ResolvedSource;
+    relativePath: string;
+    normalized: string;
+} | undefined;

package/dist/src/sources.js

@@ -0,0 +1,95 @@
+import { createHash } from "node:crypto";
+import { existsSync, lstatSync, realpathSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { basename, dirname, isAbsolute, relative, resolve, sep } from "node:path";
+import picomatch from "picomatch";
+const GLOB_MAGIC = /[*?[{(]/;
+function expandHome(value) {
+    return value === "~" ? homedir() : value.startsWith("~/") ? resolve(homedir(), value.slice(2)) : value;
+}
+function collectionName(source) {
+    return `source-${createHash("sha256").update(source).digest("hex").slice(0, 12)}`;
+}
+function assertWorkspaceSourceHasNoSymlinkRoot(workspaceDir, configuredPath, root) {
+    if (isAbsolute(expandHome(configuredPath)))
+        return;
+    const workspace = resolve(workspaceDir);
+    const rootRelative = relative(workspace, root);
+    if (rootRelative === ".." || rootRelative.startsWith(`..${sep}`) || isAbsolute(rootRelative)) {
+        return;
+    }
+    let current = root;
+    while (current !== workspace) {
+        if (existsSync(current) && lstatSync(current).isSymbolicLink()) {
+            throw new Error(`unblock-memory source path must not traverse a workspace symlink: ${configuredPath}`);
+        }
+        const parent = dirname(current);
+        if (parent === current)
+            break;
+        current = parent;
+    }
+}
+export function resolveSource(workspaceDir, configuredPath) {
+    const expanded = expandHome(configuredPath);
+    const absolute = isAbsolute(expanded) ? resolve(expanded) : resolve(workspaceDir, expanded);
+    if (existsSync(absolute)) {
+        const stat = statSync(absolute);
+        const root = stat.isDirectory() ? absolute : dirname(absolute);
+        const pattern = stat.isDirectory() ? "**/*.md" : basename(absolute);
+        assertWorkspaceSourceHasNoSymlinkRoot(workspaceDir, configuredPath, root);
+        return {
+            collection: collectionName(absolute),
+            configuredPath,
+            root,
+            pattern,
+            watchPath: absolute,
+        };
+    }
+    const magicIndex = absolute.search(GLOB_MAGIC);
+    if (magicIndex < 0) {
+        const isExactMarkdownFile = basename(absolute).toLowerCase().endsWith(".md");
+        const root = isExactMarkdownFile ? dirname(absolute) : absolute;
+        assertWorkspaceSourceHasNoSymlinkRoot(workspaceDir, configuredPath, root);
+        return {
+            collection: collectionName(absolute),
+            configuredPath,
+            root,
+            pattern: isExactMarkdownFile ? basename(absolute) : "**/*.md",
+            watchPath: absolute,
+        };
+    }
+    const prefix = absolute.slice(0, magicIndex);
+    const root = prefix.slice(0, prefix.lastIndexOf(sep)) || sep;
+    const pattern = relative(root, absolute).split(sep).join("/");
+    assertWorkspaceSourceHasNoSymlinkRoot(workspaceDir, configuredPath, root);
+    return { collection: collectionName(absolute), configuredPath, root, pattern, watchPath: root };
+}
+export function parseSafeVirtualPath(virtualPath, sources) {
+    const match = /^qmd:\/\/([^/]+)\/(.+)$/.exec(virtualPath.trim());
+    if (!match)
+        return undefined;
+    const source = sources.get(match[1]);
+    const relativePath = match[2];
+    if (!source || relativePath.includes("\0") || isAbsolute(relativePath))
+        return undefined;
+    const portableRelativePath = relativePath.split(sep).join("/");
+    if (!picomatch.isMatch(portableRelativePath, source.pattern, { dot: true }))
+        return undefined;
+    const target = resolve(source.root, relativePath);
+    if (relative(source.root, target).startsWith(`..${sep}`) || relative(source.root, target) === "..") {
+        return undefined;
+    }
+    if (!target.toLowerCase().endsWith(".md"))
+        return undefined;
+    try {
+        const realRoot = realpathSync(source.root);
+        const realTarget = realpathSync(target);
+        const rel = relative(realRoot, realTarget);
+        if (rel === ".." || rel.startsWith(`..${sep}`) || isAbsolute(rel))
+            return undefined;
+    }
+    catch {
+        return undefined;
+    }
+    return { source, relativePath, normalized: `qmd://${source.collection}/${relativePath}` };
+}

package/openclaw.plugin.json

@@ -0,0 +1,42 @@
+{
+  "id": "unblock-memory",
+  "name": "Unblock Memory",
+  "version": "0.1.1",
+  "description": "Indexes, retrieves, and analyzes configured workspace memory with existing QMD vectors.",
+  "kind": "memory",
+  "activation": { "onStartup": false },
+  "contracts": { "tools": ["memory_search", "memory_get", "memory_recluster", "memory_list_clusters", "memory_fetch_cluster"] },
+  "toolMetadata": {
+    "memory_recluster": { "sideEffecting": true },
+    "memory_list_clusters": { "replaySafe": true },
+    "memory_fetch_cluster": { "replaySafe": true }
+  },
+  "uiHints": {
+    "paths": {
+      "label": "Memory Paths",
+      "help": "Exact Markdown files, directories, or globs. Relative paths resolve from each agent workspace."
+    },
+    "analysis.executable": {
+      "label": "Memory Analysis Worker",
+      "help": "Optional absolute path to the locally installed unblock-memory-analysis executable."
+    }
+  },
+  "configSchema": {
+    "type": "object",
+    "additionalProperties": false,
+    "properties": {
+      "paths": {
+        "type": "array",
+        "items": { "type": "string", "minLength": 1 },
+        "default": ["MEMORY.md", "USER.md", "memory/**/*.md"]
+      },
+      "analysis": {
+        "type": "object",
+        "additionalProperties": false,
+        "properties": {
+          "executable": { "type": "string", "minLength": 1 }
+        }
+      }
+    }
+  }
+}

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "@unblocklabs/unblock-memory",
+  "version": "0.1.1",
+  "description": "Workspace-native memory for OpenClaw, powered by QMD",
+  "type": "module",
+  "license": "MIT",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/unblocklabs-ai/unblock-memory.git"
+  },
+  "homepage": "https://github.com/unblocklabs-ai/unblock-memory#readme",
+  "bugs": {
+    "url": "https://github.com/unblocklabs-ai/unblock-memory/issues"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "files": ["dist", "README.md", "openclaw.plugin.json"],
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "node --import tsx --test --test-concurrency=1 tests/**/*.test.ts",
+    "plugin:inspect": "plugin-inspector check --config plugin-inspector.config.json --no-openclaw",
+    "plugin:inspect:runtime": "plugin-inspector check --config plugin-inspector.config.json --no-openclaw --runtime --mock-sdk --allow-execute",
+    "release:check": "node scripts/check-release-version.mjs",
+    "preflight": "npm run build && npm run typecheck && npm test && npm run plugin:inspect && npm run plugin:inspect:runtime && npm pack --dry-run"
+  },
+  "dependencies": {
+    "@unblocklabs/qmd": "github:unblocklabs-ai/qmd#0a6b15d",
+    "chokidar": "5.0.0",
+    "picomatch": "^4.0.5",
+    "typebox": "1.3.6"
+  },
+  "devDependencies": {
+    "@openclaw/plugin-inspector": "^0.3.10",
+    "@types/node": "^24.6.0",
+    "@types/picomatch": "^4.0.2",
+    "openclaw": "2026.8.1-beta.3",
+    "tsx": "^4.20.6",
+    "typescript": "^5.9.3"
+  },
+  "peerDependencies": {
+    "openclaw": ">=2026.8.1-beta.3"
+  },
+  "peerDependenciesMeta": {
+    "openclaw": { "optional": true }
+  },
+  "engines": { "node": ">=22.0.0" },
+  "openclaw": {
+    "extensions": ["./dist/index.js"],
+    "compat": { "pluginApi": ">=2026.8.1-beta.3", "minGatewayVersion": "2026.8.1-beta.3" },
+    "build": { "openclawVersion": "2026.8.1-beta.3", "pluginSdkVersion": "2026.8.1-beta.3" },
+    "install": {
+      "npmSpec": "@unblocklabs/unblock-memory",
+      "defaultChoice": "npm",
+      "minHostVersion": ">=2026.8.1-beta.3"
+    },
+    "release": { "publishToClawHub": false, "publishToNpm": true }
+  }
+}