@unblocklabs/unblock-memory 0.9.0 → 0.10.1

package/dist/src/inside-out-runtime.js

@@ -3,7 +3,7 @@ import { resolveAgentDir, resolveStateDir } from "openclaw/plugin-sdk/memory-cor
 import { listAgentIds } from "openclaw/plugin-sdk/agent-runtime";
 import { MEMORY_DATABASE } from "./memory-database.js";
 import { dateOption } from "./date-option.js";
-import { linkInsideOutPeople, repairInsideOutIdentities, reportInsideOut, runInsideOut } from "./inside-out.js";
+import { linkInsideOutPeople, purgeInsideOutPerson, repairInsideOutIdentities, reportInsideOut, runInsideOut, refreshInsideOutBaselinesAsync, reportInsideOutBaselines } from "./inside-out.js";
 export function registerInsideOut(api, config) {
     const paths = (cfg, agentId) => {
         if (!listAgentIds(cfg).includes(agentId))
@@ -21,6 +21,7 @@ export function registerInsideOut(api, config) {
             const p = paths(cfg, opts.agent);
             const repair = opts.repairIdentities ? await repairInsideOutIdentities(p) : undefined;
             console.log(JSON.stringify({ ...repair, ...linkInsideOutPeople(p.storePath) }, null, 2));
+            await refreshInsideOutBaselinesAsync(p.storePath, { minInteractions: config.insideOut.baselineMinInteractions, link: false });
             if (repair?.errors.length)
                 process.exitCode = 1;
         });
@@ -29,24 +30,45 @@ export function registerInsideOut(api, config) {
             .action(async (opts) => {
             const result = await runInsideOut({ ...paths(cfg, opts.agent), config, retry: opts.retry, sessionId: opts.session });
             console.log(JSON.stringify(result, null, 2));
-            if ("failed" in result && (result.failed || result.errors.length))
+            if ("failed" in result && (result.failed || result.errors.length || result.baselineError))
                 process.exitCode = 1;
         });
+        root.command("baseline-refresh").description("Update local weekly baselines and missing comparisons; no Jev calls")
+            .option("--agent <id>", "Agent id", "main")
+            .option("--recompare", "Append revised comparisons using newly available historical grades; preserve earlier results")
+            .action(async (opts) => {
+            console.log(JSON.stringify(await refreshInsideOutBaselinesAsync(paths(cfg, opts.agent).storePath, { minInteractions: config.insideOut.baselineMinInteractions, recompare: opts.recompare }), null, 2));
+        });
+        root.command("baselines").description("Read person-linked weekly and cumulative baseline history")
+            .option("--agent <id>", "Agent id", "main").option("--person <id>", "Exact PeopleSQL person ID")
+            .option("--since <date>", "Inclusive UTC period-end date YYYY-MM-DD").option("--limit <n>", "Maximum weekly snapshots, 1–1000", "100")
+            .action((opts) => {
+            console.log(JSON.stringify(reportInsideOutBaselines(paths(cfg, opts.agent).storePath, { personId: opts.person, since: opts.since ? dateOption(opts.since, 0) : undefined, limit: Number(opts.limit) }), null, 2));
+        });
+        root.command("purge").description("Delete one person's emotion baselines and assessment history; no Jev calls")
+            .requiredOption("--person <id>", "Exact PeopleSQL person ID").option("--agent <id>", "Agent id", "main")
+            .option("--grades", "Also erase this person's raw emotion grades; tombstones keep those replies from being regraded")
+            .action((opts) => {
+            console.log(JSON.stringify(purgeInsideOutPerson(paths(cfg, opts.agent).storePath, opts.person, { grades: opts.grades }), null, 2));
+        });
         for (const command of ["report", "export"]) {
             root.command(command).option("--agent <id>", "Agent id", "main")
                 .option("--session <id>", "Filter one session")
                 .option("--sender <id>", "Human sender ID").option("--since <date>", "Inclusive UTC date YYYY-MM-DD")
+                .option("--person <id>", "Exact PeopleSQL person ID").option("--deviation-history", "Include previous personal comparisons (export)")
                 .option("--emotion <name>", "Filter an emotion probability").option("--min <probability>", "Minimum probability", "0")
                 .option("--bucket <period>", "day or week (report)", "day")
                 .action((opts) => {
                 console.log(JSON.stringify(reportInsideOut(paths(cfg, opts.agent).storePath, { ...opts,
-                    sessionId: opts.session, since: opts.since ? dateOption(opts.since, 0) : undefined, min: Number(opts.min), summary: command === "report" }), null, 2));
+                    sessionId: opts.session, personId: opts.person, personal: command === "export",
+                    since: opts.since ? dateOption(opts.since, 0) : undefined, min: Number(opts.min), summary: command === "report" }), null, 2));
             });
         }
     }, { descriptors: [{ name: "memory-emotions", description: "Inside Out emotion reviews and reports", hasSubcommands: true }] });
-    if (api.registrationMode === "cli-metadata" || !config.insideOut.enabled || !config.typesafe.enabled || !config.insideOut.intervalMinutes)
+    if (api.registrationMode === "cli-metadata" || !config.insideOut.enabled)
         return;
-    let timer, running;
+    let timer, baselineTimer, running;
+    let refreshing;
     let lifetime = new AbortController();
     const tick = () => {
         if (running)
@@ -59,6 +81,8 @@ export function registerInsideOut(api, config) {
                     const result = await runInsideOut({ ...paths(api.config, agentId), config, signal: lifetime.signal });
                     if ("failed" in result && (result.failed || result.errors.length))
                         api.logger.warn("Inside Out: some reviews or sources failed; inspect memory-emotions export");
+                    if ("baselineError" in result && result.baselineError)
+                        api.logger.warn(`Inside Out baselines: ${result.baselineError}`);
                 }
                 catch (error) {
                     if (!lifetime.signal.aborted)
@@ -69,10 +93,35 @@ export function registerInsideOut(api, config) {
     };
     api.on("gateway_start", () => {
         lifetime = new AbortController();
-        timer = setInterval(tick, config.insideOut.intervalMinutes * 60_000);
-        timer.unref();
-        tick();
+        const refresh = () => {
+            if (refreshing)
+                return;
+            refreshing = (async () => {
+                for (const agentId of listAgentIds(api.config)) {
+                    if (lifetime.signal.aborted)
+                        break;
+                    try {
+                        await refreshInsideOutBaselinesAsync(paths(api.config, agentId).storePath, { minInteractions: config.insideOut.baselineMinInteractions }, lifetime.signal);
+                    }
+                    catch (error) {
+                        if (!lifetime.signal.aborted)
+                            api.logger.warn(`Inside Out baselines: ${String(error)}`);
+                    }
+                }
+            })().finally(() => { refreshing = undefined; });
+        };
+        // Local statistics remain available when inference is manual-only or lacks a key.
+        baselineTimer = setInterval(refresh, 86400_000);
+        baselineTimer.unref();
+        refresh();
+        if (config.typesafe.enabled && config.insideOut.intervalMinutes) {
+            timer = setInterval(tick, config.insideOut.intervalMinutes * 60_000);
+            timer.unref();
+            tick();
+        }
     });
+    // Aborting cancels active baseline workers rather than waiting for a full historical pass.
     api.on("gateway_stop", async () => { if (timer)
-        clearInterval(timer); lifetime.abort(); await running; });
+        clearInterval(timer); if (baselineTimer)
+        clearInterval(baselineTimer); lifetime.abort(); await Promise.all([running, refreshing]); });
 }

package/dist/src/inside-out-store.d.ts

@@ -0,0 +1,61 @@
+import type { DatabaseSync } from "node:sqlite";
+import { refreshEmotionBaselines } from "./emotion-baselines.js";
+export declare const PERSON_MATCH = "SELECT min(i.person_id) person_id FROM person_identities i\n  WHERE i.provider=e.channel AND i.external_id=e.sender_id\n  AND (i.account_scope=json_extract(e.human_key,'$[1]') OR substr(json_extract(e.human_key,'$[1]'),1,8)='session:')\n  HAVING count(DISTINCT i.person_id)=1";
+export declare function openInsideOutStore(path: string): DatabaseSync;
+/**
+ * Refresh People links without loading transcripts or calling Jev. Known accounts stay exact.
+ * Purged grades stay unlinked. Matching is a read; only changed links are written, in short batches.
+ */
+export declare function linkInsideOutPeople(path: string): {
+    updated: number;
+    linked: number;
+    unlinked: number;
+};
+type BaselineOptions = {
+    minInteractions?: number;
+    now?: number;
+    recompare?: boolean;
+    link?: boolean;
+};
+type BaselineResult = ReturnType<typeof refreshEmotionBaselines>;
+/** Rebuild local statistics from existing grades, refreshing exact People links first unless the caller just did. */
+export declare function refreshInsideOutBaselines(path: string, options?: BaselineOptions): BaselineResult;
+/**
+ * Worker entry, also behind the synchronous API. `unless`: the fingerprint left by this store's
+ * previous refresh; unchanged inputs skip the pass.
+ * @public loaded by name from the worker thread
+ */
+export declare function refreshWithFingerprint(path: string, options: BaselineOptions & {
+    unless?: string;
+}): {
+    result: {
+        snapshots: number;
+        comparisons: number;
+    };
+    fingerprint?: undefined;
+} | {
+    result: {
+        snapshots: number;
+        comparisons: number;
+    };
+    fingerprint: string;
+};
+/**
+ * Keep historical aggregation off the Gateway event loop; serialize refreshes per store, and skip
+ * one whose inputs have not changed since this process's previous refresh of that store.
+ * Aborting skips queued work and terminates a running worker. Its connection closes with the
+ * worker, so SQLite rolls back the open batch; committed batches are idempotent and the next refresh resumes.
+ */
+export declare function refreshInsideOutBaselinesAsync(path: string, options?: BaselineOptions, signal?: AbortSignal): Promise<{
+    snapshots: number;
+    comparisons: number;
+}>;
+/** Operator erasure for one person; see purgeEmotionProfile. */
+export declare function purgeInsideOutPerson(path: string, personId: string, options?: {
+    grades?: boolean;
+}): {
+    baselines: number;
+    assessments: number;
+    grades: number;
+};
+export {};

package/dist/src/inside-out-store.js

@@ -0,0 +1,174 @@
+import { existsSync } from "node:fs";
+import { Worker } from "node:worker_threads";
+import { openMemoryDatabase } from "./memory-database.js";
+import { PURGED_GRADE, baselineFingerprint, purgeEmotionProfile, refreshEmotionBaselines, tableExists } from "./emotion-baselines.js";
+// Imported by the baseline worker with plain Node resolution: host SDK aliases do not
+// reach worker threads, so this module and its imports must stay free of `openclaw`.
+const SCHEMA = `CREATE TABLE IF NOT EXISTS inside_out (
+  interaction_id TEXT NOT NULL, rubric TEXT NOT NULL, session_id TEXT NOT NULL, message_id TEXT NOT NULL,
+  assistant_id TEXT NOT NULL, human_key TEXT NOT NULL, sender_id TEXT NOT NULL, channel TEXT NOT NULL, source TEXT NOT NULL,
+  target_at INTEGER, reviewed_at INTEGER NOT NULL, model TEXT NOT NULL, context_trimmed INTEGER NOT NULL,
+  joy REAL, sadness REAL, fear REAL, anger REAL, disgust REAL, surprise REAL, error TEXT, person_id TEXT,
+  PRIMARY KEY(interaction_id,rubric)
+) STRICT;
+CREATE INDEX IF NOT EXISTS inside_out_human_time ON inside_out(human_key,target_at);
+CREATE INDEX IF NOT EXISTS inside_out_failed_rubric ON inside_out(rubric,reviewed_at) WHERE error IS NOT NULL;
+CREATE TABLE IF NOT EXISTS inside_out_checkpoints (
+  source TEXT NOT NULL, rubric TEXT NOT NULL, session_id TEXT NOT NULL, signature TEXT NOT NULL,
+  revision TEXT NOT NULL, last_seq INTEGER NOT NULL,
+  PRIMARY KEY(source,rubric)
+) STRICT;`;
+// A missing account may match across scopes only when every candidate names the same person.
+export const PERSON_MATCH = `SELECT min(i.person_id) person_id FROM person_identities i
+  WHERE i.provider=e.channel AND i.external_id=e.sender_id
+  AND (i.account_scope=json_extract(e.human_key,'$[1]') OR substr(json_extract(e.human_key,'$[1]'),1,8)='session:')
+  HAVING count(DISTINCT i.person_id)=1`;
+export function openInsideOutStore(path) {
+    const db = openMemoryDatabase(path);
+    try {
+        db.exec(SCHEMA);
+        if (!db.prepare("SELECT 1 FROM pragma_table_info('inside_out') WHERE name='person_id'").get()) {
+            db.exec("ALTER TABLE inside_out ADD COLUMN person_id TEXT");
+        }
+        db.exec("CREATE INDEX IF NOT EXISTS inside_out_person_time ON inside_out(person_id,target_at)");
+        return db;
+    }
+    catch (error) {
+        db.close();
+        throw error;
+    }
+}
+/**
+ * Refresh People links without loading transcripts or calling Jev. Known accounts stay exact.
+ * Purged grades stay unlinked. Matching is a read; only changed links are written, in short batches.
+ */
+export function linkInsideOutPeople(path) {
+    const db = openInsideOutStore(path);
+    try {
+        let updated = 0;
+        if (tableExists(db, "person_identities")) {
+            const person = `(${PERSON_MATCH})`;
+            const changes = db.prepare(`SELECT e.rowid id,${person} person_id FROM inside_out e
+        WHERE e.person_id IS NOT ${person} AND e.error IS NOT ?`).all(PURGED_GRADE);
+            const link = db.prepare("UPDATE inside_out SET person_id=? WHERE rowid=? AND error IS NOT ?");
+            for (let start = 0; start < changes.length; start += 500) {
+                db.exec("BEGIN IMMEDIATE");
+                try {
+                    for (const change of changes.slice(start, start + 500))
+                        updated += Number(link.run(change.person_id, change.id, PURGED_GRADE).changes);
+                    db.exec("COMMIT");
+                }
+                catch (error) {
+                    db.exec("ROLLBACK");
+                    throw error;
+                }
+            }
+        }
+        const counts = db.prepare(`SELECT count(person_id) linked,count(*)-count(person_id) unlinked FROM inside_out`).get();
+        return { updated, linked: Number(counts.linked), unlinked: Number(counts.unlinked) };
+    }
+    finally {
+        db.close();
+    }
+}
+/** Rebuild local statistics from existing grades, refreshing exact People links first unless the caller just did. */
+export function refreshInsideOutBaselines(path, options = {}) {
+    return refreshWithFingerprint(path, options).result;
+}
+/**
+ * Worker entry, also behind the synchronous API. `unless`: the fingerprint left by this store's
+ * previous refresh; unchanged inputs skip the pass.
+ * @public loaded by name from the worker thread
+ */
+export function refreshWithFingerprint(path, options) {
+    if (!existsSync(path))
+        return { result: { snapshots: 0, comparisons: 0 } };
+    if (options.link !== false)
+        linkInsideOutPeople(path);
+    const db = openInsideOutStore(path);
+    try {
+        const settings = { ...options, minInteractions: options.minInteractions ?? 20, now: options.now ?? Date.now() };
+        if (!options.recompare && options.unless && baselineFingerprint(db, settings) === options.unless) {
+            return { result: { snapshots: 0, comparisons: 0 }, fingerprint: options.unless };
+        }
+        const result = refreshEmotionBaselines(db, settings);
+        return { result, fingerprint: baselineFingerprint(db, settings) };
+    }
+    finally {
+        db.close();
+    }
+}
+const baselineJobs = new Map();
+const fingerprints = new Map();
+/**
+ * Keep historical aggregation off the Gateway event loop; serialize refreshes per store, and skip
+ * one whose inputs have not changed since this process's previous refresh of that store.
+ * Aborting skips queued work and terminates a running worker. Its connection closes with the
+ * worker, so SQLite rolls back the open batch; committed batches are idempotent and the next refresh resumes.
+ */
+export function refreshInsideOutBaselinesAsync(path, options = {}, signal) {
+    const job = (baselineJobs.get(path) ?? Promise.resolve()).catch(() => { }).then(() => {
+        signal?.throwIfAborted();
+        if (!existsSync(path))
+            return { snapshots: 0, comparisons: 0 };
+        const settings = { ...options, now: options.now ?? Date.now(), unless: fingerprints.get(path) };
+        return new Promise((resolve, reject) => {
+            const worker = new Worker(`
+        const { parentPort, workerData } = require("node:worker_threads");
+        // tsx's CLI preload only registers on the main thread. Source-mode
+        // development needs explicit registration; compiled installs do not.
+        if (workerData.module.endsWith(".ts")) require("node:module").createRequire(workerData.module)("tsx/esm/api").register();
+        import(workerData.module).then(({ refreshWithFingerprint }) => {
+          parentPort.postMessage(refreshWithFingerprint(workerData.path, workerData.options));
+        }).catch(error => { throw error; });
+      `, { eval: true, workerData: { module: import.meta.url, path, options: settings } });
+            let outcome, aborted = false;
+            const abort = () => { aborted = true; void worker.terminate(); };
+            signal?.addEventListener("abort", abort, { once: true });
+            worker.once("message", (value) => { outcome = value; });
+            worker.once("error", reject);
+            // Settle only after the worker closes its database and exits.
+            worker.once("exit", code => {
+                signal?.removeEventListener("abort", abort);
+                if (aborted)
+                    reject(signal.reason);
+                else if (code === 0 && outcome) {
+                    if (outcome.fingerprint)
+                        fingerprints.set(path, outcome.fingerprint);
+                    resolve(outcome.result);
+                }
+                else
+                    reject(new Error(`Inside Out baseline worker exited without a result (code ${code})`));
+            });
+        });
+    }).finally(() => { if (baselineJobs.get(path) === job)
+        baselineJobs.delete(path); });
+    baselineJobs.set(path, job);
+    return job;
+}
+/** Operator erasure for one person; see purgeEmotionProfile. */
+export function purgeInsideOutPerson(path, personId, options = {}) {
+    if (!personId.trim())
+        throw new Error("A PeopleSQL person ID is required");
+    if (!existsSync(path))
+        return { baselines: 0, assessments: 0, grades: 0 };
+    // Never create Inside Out tables in a store that has none.
+    const probe = openMemoryDatabase(path);
+    try {
+        if (!tableExists(probe, "inside_out"))
+            return { baselines: 0, assessments: 0, grades: 0 };
+    }
+    finally {
+        probe.close();
+    }
+    // Erasing grades must cover replies linked to this person since the last refresh.
+    if (options.grades)
+        linkInsideOutPeople(path);
+    const db = openInsideOutStore(path);
+    try {
+        return purgeEmotionProfile(db, personId, options);
+    }
+    finally {
+        db.close();
+    }
+}

package/dist/src/inside-out.d.ts

@@ -1,18 +1,15 @@
 import type { UnblockMemoryConfig } from "./config.js";
 import { readInsideOutSources } from "./inside-out-sources.js";
+import { emotionBaselineHistory } from "./emotion-baselines.js";
+export { linkInsideOutPeople, purgeInsideOutPerson, refreshInsideOutBaselines, refreshInsideOutBaselinesAsync } from "./inside-out-store.js";
 export type InsideOutConfig = {
     enabled: boolean;
     intervalMinutes: number;
     maxInteractions: number;
     maxContextTokens: number;
+    baselineMinInteractions: number;
 };
 export declare function resolveInsideOut(value: unknown): InsideOutConfig;
-/** Refresh People links without loading transcripts or calling Jev. Known accounts stay exact. */
-export declare function linkInsideOutPeople(path: string): {
-    updated: number;
-    linked: number;
-    unlinked: number;
-};
 /** Explicit legacy repair: only read sources owning unlinked reviews; never rejudge their text. */
 export declare function repairInsideOutIdentities(options: Parameters<typeof readInsideOutSources>[0] & {
     storePath: string;
@@ -36,9 +33,144 @@ export declare function runInsideOut(options: {
     sources: number;
     skippedSources: number;
     errors: string[];
+    baselineError?: string;
 } | {
     status: string;
 }>;
+export declare function reportInsideOutBaselines(path: string, options?: Parameters<typeof emotionBaselineHistory>[1]): {
+    id: string;
+    person_id: string;
+    rubric: string;
+    model: string;
+    version: string;
+    week_start: number;
+    week_end: number;
+    computed_at: number;
+    weekly: {
+        joy: {
+            count: number;
+            mean: number | null;
+            min: number | null;
+            p10: number | null;
+            median: number | null;
+            p90: number | null;
+            max: number | null;
+            distribution: [number, number][];
+        };
+        sadness: {
+            count: number;
+            mean: number | null;
+            min: number | null;
+            p10: number | null;
+            median: number | null;
+            p90: number | null;
+            max: number | null;
+            distribution: [number, number][];
+        };
+        fear: {
+            count: number;
+            mean: number | null;
+            min: number | null;
+            p10: number | null;
+            median: number | null;
+            p90: number | null;
+            max: number | null;
+            distribution: [number, number][];
+        };
+        anger: {
+            count: number;
+            mean: number | null;
+            min: number | null;
+            p10: number | null;
+            median: number | null;
+            p90: number | null;
+            max: number | null;
+            distribution: [number, number][];
+        };
+        disgust: {
+            count: number;
+            mean: number | null;
+            min: number | null;
+            p10: number | null;
+            median: number | null;
+            p90: number | null;
+            max: number | null;
+            distribution: [number, number][];
+        };
+        surprise: {
+            count: number;
+            mean: number | null;
+            min: number | null;
+            p10: number | null;
+            median: number | null;
+            p90: number | null;
+            max: number | null;
+            distribution: [number, number][];
+        };
+    };
+    cumulative: {
+        joy: {
+            count: number;
+            mean: number | null;
+            min: number | null;
+            p10: number | null;
+            median: number | null;
+            p90: number | null;
+            max: number | null;
+            distribution: [number, number][];
+        };
+        sadness: {
+            count: number;
+            mean: number | null;
+            min: number | null;
+            p10: number | null;
+            median: number | null;
+            p90: number | null;
+            max: number | null;
+            distribution: [number, number][];
+        };
+        fear: {
+            count: number;
+            mean: number | null;
+            min: number | null;
+            p10: number | null;
+            median: number | null;
+            p90: number | null;
+            max: number | null;
+            distribution: [number, number][];
+        };
+        anger: {
+            count: number;
+            mean: number | null;
+            min: number | null;
+            p10: number | null;
+            median: number | null;
+            p90: number | null;
+            max: number | null;
+            distribution: [number, number][];
+        };
+        disgust: {
+            count: number;
+            mean: number | null;
+            min: number | null;
+            p10: number | null;
+            median: number | null;
+            p90: number | null;
+            max: number | null;
+            distribution: [number, number][];
+        };
+        surprise: {
+            count: number;
+            mean: number | null;
+            min: number | null;
+            p10: number | null;
+            median: number | null;
+            p90: number | null;
+            max: number | null;
+            distribution: [number, number][];
+        };
+    };
+}[];
 export declare function reportInsideOut(path: string, options?: {
     summary?: boolean;
     sender?: string;
@@ -47,4 +179,7 @@ export declare function reportInsideOut(path: string, options?: {
     emotion?: string;
     min?: number;
     bucket?: string;
-}): Record<string, import("node:sqlite").SQLOutputValue>[];
+    personId?: string;
+    personal?: boolean;
+    deviationHistory?: boolean;
+}): Record<string, unknown>[];