@unblocklabs/unblock-memory 0.6.2 → 0.7.0

package/dist/src/manager.js

@@ -2,6 +2,7 @@ import { createHash } from "node:crypto";
 import { readdirSync, readFileSync, realpathSync, statSync } from "node:fs";
 import { mkdir, stat } from "node:fs/promises";
 import { basename, dirname, relative, resolve, sep } from "node:path";
+import { EXTRACTED_COLLECTION, extractedRecords, extractedPath, extractedHit, syncExtractedIndex } from "./extraction-index.js";
 import chokidar from "chokidar";
 import picomatch from "picomatch";
 import { ensureMemoryAnalysisSchema, latestAnalysisCollections, latestAnalysisRunId, markMemoryAnalysisStale, readAnalysisSummary, readCluster, readClusters, runAnalysisWorker, } from "./analysis.js";
@@ -236,6 +237,7 @@ export class QmdMemoryManager {
     #dbPath;
     #workspaceDir;
     #curationPath;
+    #extraction;
     #sources;
     #storeFactory;
     #keepModelsWarm;
@@ -287,6 +289,7 @@ export class QmdMemoryManager {
     constructor(params) {
         this.#dbPath = params.dbPath;
         this.#curationPath = params.curationPath ?? `${params.dbPath}.curation.sqlite`;
+        this.#extraction = params.extraction;
         this.#workspaceDir = params.workspaceDir;
         this.#sources = new Map(params.sources.map((source) => [source.collection, source]));
         this.#storeFactory = params.storeFactory;
@@ -384,10 +387,11 @@ export class QmdMemoryManager {
             dbPath: this.#dbPath,
             keepModelsWarm: this.#keepModelsWarm,
             config: {
-                collections: Object.fromEntries(this.#qmdSources().map((source) => [
-                    source.collection,
-                    { path: source.root, pattern: source.pattern },
-                ])),
+                collections: Object.fromEntries([...this.#qmdSources().map((source) => [
+                        source.collection,
+                        { path: source.root, pattern: source.pattern },
+                    ]), ...(this.#extraction?.enabled && this.#extraction.publish
+                        ? [[EXTRACTED_COLLECTION, { path: dirname(this.#dbPath), pattern: ".no-extracted-files", includeByDefault: false }]] : [])]),
             },
         });
         try {
@@ -395,6 +399,8 @@ export class QmdMemoryManager {
             ensureMemoryAnalysisSchema(store.internal.db);
             markStaleForAnalysisCollectionChange(store.internal.db, this.#analysisCollectionNames(), this.#skillCollectionNames().length > 0);
             const configuredCollections = new Set(this.#qmdSources().map((source) => source.collection));
+            if (this.#extraction?.enabled && this.#extraction.publish)
+                configuredCollections.add(EXTRACTED_COLLECTION);
             const staleCollections = (await store.getStatus()).collections
                 .map((collection) => collection.name)
                 .filter((collection) => !configuredCollections.has(collection));
@@ -441,26 +447,51 @@ export class QmdMemoryManager {
     }
     #collectionNames(corpora) {
         const publicSources = [...this.#sources.values()].filter((source) => source.kind !== "skills");
+        const extracted = this.#extraction?.enabled && this.#extraction.publish ? [EXTRACTED_COLLECTION] : [];
         if (corpora === undefined)
-            return publicSources.map((source) => source.collection);
+            return [...publicSources.map((source) => source.collection), ...extracted];
         if (corpora.length === 0)
             throw new Error("memory_search corpora must not be empty");
         const selected = new Set(corpora);
         if (selected.has("all")) {
             if (selected.size > 1)
                 throw new Error('memory_search corpus "all" must be used alone');
-            return publicSources.map((source) => source.collection);
+            return [...publicSources.map((source) => source.collection), ...extracted];
         }
         const known = new Set(publicSources.map((source) => source.corpus));
+        if (extracted.length)
+            known.add("extracted");
         const unknown = [...selected].find((corpus) => !known.has(corpus));
         if (unknown)
             throw new Error(`memory_search unknown corpus: ${unknown}`);
-        return publicSources
-            .filter((source) => selected.has(source.corpus))
-            .map((source) => source.collection);
+        return [...publicSources
+                .filter((source) => selected.has(source.corpus))
+                .map((source) => source.collection), ...(selected.has("extracted") ? extracted : [])];
+    }
+    syncExtracted() {
+        return this.#enqueue(async () => {
+            if (!this.#extraction?.enabled || !this.#extraction.publish)
+                return;
+            const store = await this.#getAnalysisStore();
+            const records = extractedRecords(this.#curationPath).filter(r => this.#extraction.chatTypes.includes(r.metadata.chatType));
+            await syncExtractedIndex(store, records);
+            await this.#refreshIndexStatus(store);
+        });
+    }
+    #currentExtracted(paths, filter) {
+        if (!this.#extraction?.enabled || !this.#extraction.publish)
+            return [];
+        const records = extractedRecords(this.#curationPath, paths?.filter(path => path.startsWith(`qmd://${EXTRACTED_COLLECTION}/`))
+            .map(path => path.slice(`qmd://${EXTRACTED_COLLECTION}/`.length)))
+            .filter(r => this.#extraction.chatTypes.includes(r.metadata.chatType));
+        if (!filter)
+            return records;
+        const allowed = new Set(sessionAllowedPaths(new Map(records.map(r => [extractedPath(r), r.metadata])), EXTRACTED_COLLECTION, filter)[EXTRACTED_COLLECTION]);
+        return records.filter(r => allowed.has(extractedPath(r)));
     }
     async #updateAndEmbed(store, collection, force) {
-        const update = await store.update({ collections: collection ? [collection] : [] });
+        // Extracted facts are DB projections, not files: never run filesystem sync on them.
+        const update = await store.update({ collections: collection ? [collection] : this.#qmdSources().map(source => source.collection) });
         this.#cleanupRemovedDocuments?.(update.updated + update.removed);
         const analysisStore = store;
         const changed = update.indexed + update.updated + update.removed > 0 || update.needsEmbedding > 0;
@@ -776,17 +807,30 @@ export class QmdMemoryManager {
         if (sessions && collections.includes(sessions.collection)) {
             await this.#refreshSessionMetadata();
         }
-        const allowedPaths = opts?.sessionFilter && sessions && collections.includes(sessions.collection)
+        let allowedPaths = opts?.sessionFilter && sessions && collections.includes(sessions.collection)
             ? sessionAllowedPaths(this.#sessionMetadata, sessions.collection, opts.sessionFilter)
             : undefined;
         const store = await this.#getStore();
         opts?.signal?.throwIfAborted();
+        const currentRecords = (paths) => {
+            if (!collections.includes(EXTRACTED_COLLECTION))
+                return [];
+            return this.#currentExtracted(paths, opts?.sessionFilter);
+        };
+        if (collections.includes(EXTRACTED_COLLECTION)) {
+            allowedPaths = { ...allowedPaths, [EXTRACTED_COLLECTION]: currentRecords().map(extractedPath) };
+        }
         if (opts?.lexicalOnly) {
             const hits = await store.searchLex(query, {
                 limit: opts.maxResults ?? 5,
                 collection: collections,
             });
+            const current = new Map(currentRecords(hits.map(hit => hit.filepath)).map(r => [`qmd://${EXTRACTED_COLLECTION}/${extractedPath(r)}`, r]));
             return hits.flatMap((hit) => {
+                if (hit.collectionName === EXTRACTED_COLLECTION) {
+                    const record = current.get(hit.filepath);
+                    return record && hit.score >= (opts.minScore ?? 0) ? [extractedHit(record, hit.score)] : [];
+                }
                 const corpus = this.#sources.get(hit.collectionName)?.corpus;
                 const prefix = `qmd://${hit.collectionName}/`;
                 const session = corpus === "sessions" && hit.filepath.startsWith(prefix)
@@ -833,6 +877,7 @@ export class QmdMemoryManager {
     async #renderSearchHits(hits, store, opts, whisperer = false) {
         const tokenizer = store.internal?.llm;
         const results = [];
+        const current = new Map(this.#currentExtracted(hits.map(hit => hit.file), opts?.sessionFilter).map(r => [`qmd://${EXTRACTED_COLLECTION}/${extractedPath(r)}`, r]));
         for (const hit of hits) {
             opts?.signal?.throwIfAborted();
             // Proactive hints must retain the entire matched chunk, even when expanded
@@ -840,6 +885,12 @@ export class QmdMemoryManager {
             if (hit.bestChunk.length > (opts?.maxSnippetChars ?? Infinity))
                 continue;
             const collection = /^qmd:\/\/([^/]+)\//.exec(hit.file)?.[1];
+            if (collection === EXTRACTED_COLLECTION) {
+                const record = current.get(hit.file);
+                if (record && record.text.length <= (opts?.maxSnippetChars ?? Infinity))
+                    results.push(extractedHit(record, hit.score));
+                continue;
+            }
             const corpus = collection ? this.#sources.get(collection)?.corpus : undefined;
             if (!corpus)
                 continue;
@@ -880,7 +931,9 @@ export class QmdMemoryManager {
                 citation: `${hit.displayPath}#L${span.startLine}-L${span.endLine}`,
             });
         }
-        return results;
+        // Expansion above can yield; recheck only derived hits once more before returning.
+        const finalPaths = new Set(this.#currentExtracted(results.map(hit => hit.path), opts?.sessionFilter).map(r => `qmd://${EXTRACTED_COLLECTION}/${extractedPath(r)}`));
+        return results.filter(hit => !hit.path.startsWith(`qmd://${EXTRACTED_COLLECTION}/`) || finalPaths.has(hit.path));
     }
     async searchSkills(query, minScore, limit) {
         const collections = this.#skillCollectionNames();
@@ -942,6 +995,13 @@ export class QmdMemoryManager {
             .slice(0, limit);
     }
     async readFile(params) {
+        if (params.relPath.startsWith(`qmd://${EXTRACTED_COLLECTION}/`)) {
+            const record = this.#extraction?.enabled && this.#extraction.publish
+                ? extractedRecords(this.#curationPath, [params.relPath.slice(`qmd://${EXTRACTED_COLLECTION}/`.length)]).find(r => this.#extraction.chatTypes.includes(r.metadata.chatType) &&
+                    params.relPath === `qmd://${EXTRACTED_COLLECTION}/${extractedPath(r)}`) : undefined;
+            return record ? buildReadResult({ content: `${record.text}\nObserved: ${new Date(record.observedAt).toISOString()}\nSource: ${extractedHit(record, 1).citation}`,
+                path: params.relPath, from: params.from, lines: params.lines }) : { status: "not_found", text: "", path: params.relPath };
+        }
         const safe = parseSafeVirtualPath(params.relPath, this.#sources);
         if (!safe || safe.source.kind === "skills") {
             return { status: "not_found", text: "", path: params.relPath };

package/dist/src/plugin.js

@@ -18,6 +18,7 @@ import { registerResponseAudit } from "./response-runtime.js";
 import { registerInsideOut } from "./inside-out-runtime.js";
 import { registerMemoryTraining } from "./training-runtime.js";
 import { resolveTimezone } from "./session-projector.js";
+import { registerExtraction } from "./extraction-runtime.js";
 const searchParameters = Type.Object({
     query: Type.String({ pattern: "\\S" }),
     corpora: Type.Optional(Type.Array(Type.String({ pattern: "\\S" }), {
@@ -417,12 +418,16 @@ export function registerUnblockMemory(api) {
     registerResponseAudit(api, config);
     registerInsideOut(api, config);
     registerMemoryTraining(api, config);
-    if (api.registrationMode === "cli-metadata")
+    if (api.registrationMode === "cli-metadata") {
+        registerExtraction(api, config);
         return;
+    }
     const runtime = new QmdMemoryRuntime(config.corpora, {
         analysisExecutable: config.analysis.executable,
         keepEmbeddingModelWarm: config.keepEmbeddingModelWarm,
+        extraction: config.extraction,
     });
+    registerExtraction(api, config, runtime);
     const capability = {
         deterministicRecallToolName: "memory_search",
         supportsPrivateTranscriptRecall: false,

package/dist/src/response-judge.d.ts

@@ -70,7 +70,7 @@ declare const qualitySchema: Type.TObject<{
         }>;
         consistency: Type.TObject<{
             type: Type.TLiteral<"choice">;
-            choice: Type.TEnum<("not_assessable" | "consistent" | "contradicted")[]>;
+            choice: Type.TEnum<("contradicted" | "not_assessable" | "consistent")[]>;
             confidence: Type.TNumber;
             probabilities: Type.TObject<{
                 [k: string]: Type.TNumber;

package/dist/src/response-stages.d.ts

@@ -91,29 +91,29 @@ export declare function assessResponseStages(store: ResponseAuditStore, cohort:
         fulfillment: {
             type: "score";
             confidence: number;
-            score: number;
             probabilities: {
                 "0": number;
                 "1": number;
                 "2": number;
                 "3": number;
             };
+            score: number;
         };
         deliverableFit: {
             type: "score";
             confidence: number;
-            score: number;
             probabilities: {
                 "0": number;
                 "1": number;
                 "2": number;
                 "3": number;
             };
+            score: number;
         };
         consistency: {
             type: "choice";
             confidence: number;
-            choice: "not_assessable" | "consistent" | "contradicted";
+            choice: "contradicted" | "not_assessable" | "consistent";
             probabilities: {
                 [x: string]: number;
                 [x: number]: number;
@@ -172,13 +172,13 @@ export declare function assessResponseStages(store: ResponseAuditStore, cohort:
         dissatisfactionIntensity: {
             type: "score";
             confidence: number;
-            score: number;
             probabilities: {
                 "0": number;
                 "1": number;
                 "2": number;
                 "3": number;
             };
+            score: number;
         };
     }>;
 }>;

package/dist/src/runtime.d.ts

@@ -1,5 +1,6 @@
 import type { OpenClawConfig } from "openclaw/plugin-sdk/plugin-entry";
 import type { CorpusConfig } from "./config.js";
+import type { ExtractionConfig } from "./extraction-config.js";
 import type { MemoryPluginRuntimeContract } from "./contracts.js";
 import { QmdMemoryManager } from "./manager.js";
 import { type SessionSyncResult } from "./session-sync.js";
@@ -46,6 +47,7 @@ export declare class QmdMemoryRuntime implements MemoryPluginRuntimeContract {
         analysisExecutable?: string;
         keepEmbeddingModelWarm?: boolean;
         stateRoot?: string;
+        extraction?: ExtractionConfig;
     });
     getMemorySearchManager(params: {
         cfg: OpenClawConfig;

package/dist/src/runtime.js

@@ -66,6 +66,7 @@ export async function recoverInterruptedSessionSync(directory, statusPath, stale
 }
 export class QmdMemoryRuntime {
     #corpora;
+    #extraction;
     #analysisExecutable;
     #keepEmbeddingModelWarm;
     #stateRoot;
@@ -90,6 +91,7 @@ export class QmdMemoryRuntime {
     }
     constructor(corpora, options = {}) {
         this.#corpora = corpora;
+        this.#extraction = options.extraction;
         this.#analysisExecutable = options.analysisExecutable;
         this.#keepEmbeddingModelWarm = options.keepEmbeddingModelWarm ?? true;
         this.#stateRoot = options.stateRoot ?? resolveStateDir();
@@ -242,6 +244,7 @@ export class QmdMemoryRuntime {
             workspaceDir,
             dbPath: join(stateDir, "index.sqlite"),
             curationPath: join(stateDir, MEMORY_DATABASE),
+            extraction: this.#extraction,
             sources,
             keepModelsWarm: this.#keepEmbeddingModelWarm,
             analysisExecutable: this.#analysisExecutable,

package/dist/src/session-projector.d.ts

@@ -1,4 +1,5 @@
 import type { ChatType } from "./config.js";
+import { projectLoggieMessage } from "./loggie-projection.js";
 export type SessionMetadata = {
     sessionId: string;
     provider?: string;
@@ -22,6 +23,13 @@ export type SessionProjectionInput = SessionMetadata & {
         attachmentBudgetSkipped: number;
     };
 };
+type ProjectedMessage = {
+    role: "user" | "assistant";
+    speaker: string;
+    text: string;
+    timestamp: number;
+    meeting?: ReturnType<typeof projectLoggieMessage>;
+};
 export type SessionSnippetMessage = {
     type?: "user" | "assistant";
     name?: string;
@@ -49,6 +57,7 @@ export type SessionContextSpans = {
         end: number;
     };
 };
+export declare function projectMessage(row: SessionProjectionInput["events"][number], input: SessionProjectionInput): ProjectedMessage | undefined;
 export declare function projectSession(input: SessionProjectionInput): string | undefined;
 export declare function projectSessionDocument(input: SessionProjectionInput): {
     content: string;
@@ -67,3 +76,4 @@ export declare function sessionSnippetMessages(content: string, selected: {
 }): SessionSnippetMessage[];
 export declare function sessionDocumentPath(metadata: SessionMetadata): string;
 export declare function resolveTimezone(configured?: string): string;
+export {};

package/dist/src/session-projector.js

@@ -37,7 +37,7 @@ function textContent(value) {
     }).join("\n").trim();
     return text || undefined;
 }
-function projectMessage(row, input) {
+export function projectMessage(row, input) {
     let event;
     try {
         event = JSON.parse(row.eventJson);

package/docs/configuration.md

@@ -176,6 +176,15 @@ Set this only after [installing the worker](retrieval.md#memory-analysis). No
 clustering or curation schedule is created. Response-audit setup and a dry-run-first
 workflow are in [its own guide](response-audit.md).
 
+## Session memory extraction
+
+See [the extraction guide](extraction.md) for source approval, host LLM policy,
+single-session validation, backfill, and publication. Defaults: disabled,
+`publish: false`, `chatTypes: []`, hourly, six overlap messages, five chunks per run.
+`extraction.minSupport`, `minRetention`, and `minReplacement` independently accept
+0–1 and default to 0.90. Settings are operator-controlled; reload/restart after edits.
+Extraction always uses its own 10-second Jev deadline, not `typesafe.timeoutMs`.
+
 ## Settings reference
 
 The tables show resolved defaults. For source-specific entries,

package/docs/extraction.md

@@ -0,0 +1,124 @@
+# Session memory extraction
+
+Opt-in lasting-fact extraction: **Luna proposes facts → code checks exact quotes →
+Jev checks support and retention → SQLite stores accepted facts → optional QMD search.**
+It is independent of Inside Out: emotion scores do not select or strengthen memories.
+It never writes `MEMORY.md`, daily Markdown, or people dossiers.
+
+## Enable in shadow mode first
+
+Merge this fragment under `plugins.entries.unblock-memory.config`, preserving
+existing corpora and settings. Extraction chat types must be explicitly approved
+and be a subset of the configured sessions corpus. This is channel agnostic.
+
+```json
+{
+  "corpora": [
+    { "name": "memory", "kind": "files", "paths": ["MEMORY.md", "USER.md", "memory/**/*.md"] },
+    { "name": "sessions", "kind": "sessions", "chatTypes": ["channel", "group"] }
+  ],
+  "extraction": {
+    "enabled": true,
+    "publish": false,
+    "chatTypes": ["channel", "group"],
+    "intervalMinutes": 60,
+    "historyMessages": 6,
+    "maxBatches": 5,
+    "minSupport": 0.90,
+    "minRetention": 0.90,
+    "minReplacement": 0.90
+  }
+}
+```
+
+Configure [TypeSafe credentials](configuration.md#typesafe-and-whisperers).
+Manual runs use the same Gateway-owned worker as scheduled runs; the Gateway must
+be running and the CLI caller needs `operator.admin`. Reports can be read offline.
+Requires host visible-transcript delta reads and working isolated LLM completion
+(validated on OpenClaw 2026.9.2 with Codex 0.159.2). The native harness must be
+installed through OpenClaw, not merely added to `plugins.load.paths`. Grant this
+host policy **alongside `config`** in the plugin entry:
+
+```json
+{
+  "llm": {
+    "allowAgentIdOverride": true,
+    "allowModelOverride": true,
+    "allowedModels": ["openai/gpt-5.6-luna"],
+    "allowedCompletionModels": ["openai/gpt-5.6-luna"]
+  }
+}
+```
+
+Luna uses the host's configured agent runtime and credentials, with zero tools and
+no alternate-model/provider fallback. Missing TypeSafe credentials prevent source
+scans and model calls. Enabling approves sending selected conversation text to
+Luna and Jev; tool calls/results and hidden thinking are removed first.
+
+## Run, backfill, inspect
+
+```sh
+openclaw memory-extract run --agent main --since 2026-09-01 --session SESSION_ID
+openclaw memory-extract report --agent main
+openclaw memory-extract run --agent main --since 2026-09-01
+```
+
+Without `--since`, the first enabled run establishes a live start time; historical
+messages require an explicit backfill. Runs process at most `maxBatches` session
+chunks; repeat the same command to continue. The approved backfill boundary and
+cursors persist across restarts and scheduled runs. An earlier `--since` replays
+history without deleting retained facts. Unchanged reruns make no model calls;
+new messages resume from each session's cursor. Failed chunks do not advance it.
+
+## Retention and thresholds
+
+Retain explicit identities, relationships, ongoing responsibilities, stable
+preferences, enduring project purposes, and adopted standing rules. Omit guesses,
+hypotheticals, one-off tasks, temporary status, release/incident details, generic
+technical knowledge, and credentials. The original transcripts remain searchable.
+
+A blue guess followed by a human correction to red retains only the red preference.
+Each proposal needs exact supporting quotes and new-message evidence. Jev checks
+support and retention independently in one request; replacements also require an
+explicit update to the same fact. All applicable thresholds must pass, and support
+must select `supported`, even if its threshold is lowered.
+
+The three thresholds accept 0–1 and default to 0.90. Lowering retention changes
+certainty about category membership, not the categories themselves. Agents can
+edit configuration when instructed, then reload/restart the Gateway; they must
+not silently lower thresholds. Decisions store their probabilities and thresholds
+for inspection. Changing thresholds affects future processing, not existing records;
+rejected proposals are not kept for automatic regrading.
+
+## Storage, search, and limits
+
+Three tables in the existing agent `unblock-memory.sqlite` store worker state,
+session checkpoints, and versioned facts/evidence/judgments. Facts and checkpoints
+commit together. Deduplication/corrections are per session, not cross-session;
+older evidence cannot overwrite a newer observation. Source resets/deletions
+withdraw affected facts when the worker next checks them. Reports include accepted
+facts, judgments, checkpoints, and source/proposal/validation/commit failure stages
+without leaking provider errors or source text into error messages.
+
+`publish: false` stores accepted facts for evaluation only. `publish: true` indexes
+them in the existing QMD `index.sqlite`; `memory_search` includes them by default,
+or use `corpora: ["extracted"]`. `memory_get` checks the current active revision.
+No automatic whisperer/dossier changes are introduced. Published facts can be
+retrieved across this agent's audiences; this is **not per-person access control**.
+Do not approve private conversations for a shared agent unless sharing is intended.
+
+The Gateway owns the scheduler; no cron/launchd job is added. Interval 0 means
+manual-only; the maximum is 1,440 minutes (daily). Defaults are disabled, unpublished,
+no approved chat types, hourly, six overlap messages, and five chunks per run.
+
+Chunks target 24k input tokens and cap at 28k, including Luna instructions, prior
+facts and overlap, leaving room for Jev's 32k state-plus-longest-question limit.
+`o200k_base` is a budgeting proxy, not an exact Jev/host token count. Quotes are
+limited to 512 characters each. Up to six overlap messages fit within 8k tokens by
+default. Oversized messages split losslessly with resumable offsets and original
+message-ID citations. A session above 100 retained facts or 40k characters of prior
+facts pauses rather than silently dropping comparison context. The output limit
+is advisory on some host runtimes; malformed/truncated JSON is retried, never saved.
+
+This is a conservative v1, not a calibrated guarantee of memory recall or truth.
+Start with a single-session shadow run and inspect the retained facts before publishing.

package/openclaw.plugin.json

@@ -1,7 +1,7 @@
 {
   "id": "unblock-memory",
   "name": "Unblock Memory",
-  "version": "0.6.2",
+  "version": "0.7.0",
   "description": "Indexes, retrieves, and analyzes configured workspace memory with existing QMD vectors.",
   "kind": "memory",
   "activation": { "onStartup": true },
@@ -119,6 +119,20 @@
           "maxContextTokens": { "type": "integer", "minimum": 256, "maximum": 30000, "default": 30000 }
         }
       },
+      "extraction": {
+        "type": "object", "additionalProperties": false,
+        "properties": {
+          "enabled": { "type": "boolean", "default": false },
+          "publish": { "type": "boolean", "default": false },
+          "intervalMinutes": { "type": "integer", "minimum": 0, "maximum": 1440, "default": 60 },
+          "chatTypes": { "type": "array", "items": { "enum": ["direct", "channel", "group"] }, "default": [] },
+          "historyMessages": { "type": "integer", "minimum": 0, "maximum": 20, "default": 6 },
+          "maxBatches": { "type": "integer", "minimum": 1, "maximum": 50, "default": 5 },
+          "minSupport": { "type": "number", "minimum": 0, "maximum": 1, "default": 0.9 },
+          "minRetention": { "type": "number", "minimum": 0, "maximum": 1, "default": 0.9 },
+          "minReplacement": { "type": "number", "minimum": 0, "maximum": 1, "default": 0.9 }
+        }
+      },
       "responseAudit": {
         "type": "object", "additionalProperties": false,
         "properties": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unblocklabs/unblock-memory",
-  "version": "0.6.2",
+  "version": "0.7.0",
   "description": "Workspace-native memory for OpenClaw, powered by QMD",
   "type": "module",
   "license": "MIT",
@@ -30,6 +30,7 @@
     "docs/peoplesql.md",
     "docs/response-audit.md",
     "docs/memory-training.md",
+    "docs/extraction.md",
     "openclaw.plugin.json"
   ],
   "scripts": {
@@ -47,6 +48,7 @@
     "@huggingface/tokenizers": "0.2.0",
     "@unblocklabs/qmd": "https://github.com/unblocklabs-ai/qmd/releases/download/v2.10.3/unblocklabs-qmd-2.10.3.tgz",
     "chokidar": "5.0.0",
+    "js-tiktoken": "1.0.21",
     "picomatch": "^4.0.5",
     "typebox": "1.3.6"
   },