hippo-memory 1.68.0 → 1.70.0

package/dist/{http-util.js → util/http-util.js}

@@ -1,9 +1,7 @@
-import { ApiError } from './api-errors.js';
-import { SqliteBlockedError } from './db/sqlite-blocked.js';
+import { ApiError } from '../core/api-errors.js';
+import { SqliteBlockedError } from './sqlite-blocked.js';
+import { envBodyTimeoutMs } from './env.js';
 // Leaf module shared by server.ts and the connector webhook receivers; it must not import either.
-export function isJsonObjectRecord(value) {
-    return value !== undefined && value !== null && typeof value === 'object' && !Array.isArray(value);
-}
 // node:http header values are `string | string[] | undefined` (never a bare
 // unknown), so this gets its own predicate rather than reusing isJsonString.
 export function isHeaderString(value) {
@@ -11,7 +9,7 @@ export function isHeaderString(value) {
 }
 // 1 MB body cap. The CLI never sends payloads near this; anything bigger is
 // almost certainly a misconfigured client or a deliberate memory-blowup attempt.
-const MAX_BODY_BYTES = 1024 * 1024;
+export const MAX_BODY_BYTES = 1024 * 1024;
 function sizeLabel(bytes) {
     return bytes % (1024 * 1024) === 0 ? `${bytes / (1024 * 1024)}MB` : `${Math.ceil(bytes / 1024)}KB`;
 }
@@ -30,6 +28,13 @@ export class HttpError extends Error {
         this.retryAfterSec = retryAfterSec;
     }
 }
+/** A request, or a store call it waited on, ran past the request's deadline; the reply carries `code` so a client branches without parsing prose. */
+export class DeadlineExceededError extends HttpError {
+    code = 'deadline_exceeded';
+    constructor(message) {
+        super(504, message);
+    }
+}
 export class BodyTooLargeError extends Error {
 }
 /** The body did not arrive in time. Its own class so mapApiError answers 408 and the server drops the socket. */
@@ -62,12 +67,16 @@ export function sendJson(res, status, body) {
     res.writeHead(status, JSON_HEADERS);
     res.end(text);
 }
+const DEFAULT_BODY_DEADLINE_MS = 30_000;
+/** How long any route waits for a request body, so a client that sends headers and then stalls cannot hold a request open: 30 s, or HIPPO_BODY_TIMEOUT_MS. */
+export function bodyDeadlineMs() {
+    return envBodyTimeoutMs() ?? DEFAULT_BODY_DEADLINE_MS;
+}
 /** The body as text, refused mid-stream past maxBytes and past deadlineMs, so an oversized or slow sender cannot tie up the server. */
-export function readBody(req, { maxBytes = MAX_BODY_BYTES, deadlineMs } = {}) {
+export function readBody(req, { maxBytes = MAX_BODY_BYTES, deadlineMs = bodyDeadlineMs() } = {}) {
     return new Promise((resolve, reject) => {
         const chunks = [];
         let total = 0;
-        let timer;
         const refuse = (err) => {
             clearTimeout(timer);
             req.off('data', onData);
@@ -83,9 +92,7 @@ export function readBody(req, { maxBytes = MAX_BODY_BYTES, deadlineMs } = {}) {
             }
             refuse(new BodyTooLargeError(`request body exceeds ${sizeLabel(maxBytes)}`));
         };
-        if (deadlineMs !== undefined) {
-            timer = setTimeout(() => refuse(new BodyTimeoutError(`request body not received within ${deadlineMs} ms`)), deadlineMs);
-        }
+        const timer = setTimeout(() => refuse(new BodyTimeoutError(`request body not received within ${deadlineMs} ms`)), deadlineMs);
         req.on('data', onData);
         req.once('end', () => {
             clearTimeout(timer);
@@ -116,4 +123,17 @@ export function isCrossSite(req) {
     const origin = req.headers.origin;
     return origin !== undefined && origin !== `http://${req.headers.host}`;
 }
+// A webhook route takes no key, so anyone holding a signature header could otherwise keep a socket open with a body that never ends.
+const WEBHOOK_BODY_DEADLINE_MS = 10_000;
+/** Call before refusing a webhook unread: a caller still sending its body loses the socket once the reply is out, as it does after a 413. */
+export function closeIfBodyUnread({ req, res }) {
+    res.once('finish', () => {
+        if (!req.complete)
+            closeAfterReply(req);
+    });
+}
+/** A webhook's raw body, exactly as sent, for the receiver's HMAC check; call it only once a secret is configured and the signature headers are present. */
+export function readWebhookBody({ req, opts }) {
+    return readBody(req, { deadlineMs: opts.webhookBodyDeadlineMs ?? WEBHOOK_BODY_DEADLINE_MS });
+}
 //# sourceMappingURL=http-util.js.map

package/dist/util/json.d.ts

@@ -0,0 +1,17 @@
+export type JsonValue = string | number | boolean | null | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+export declare function isJsonString(value: JsonValue | undefined): value is string;
+export declare function isJsonNumber(value: JsonValue | undefined): value is number;
+export declare function isJsonBoolean(value: JsonValue | undefined): value is boolean;
+/** A non-null, non-array object. */
+export declare function isJsonObject(value: JsonValue | undefined): value is {
+    [key: string]: JsonValue;
+};
+/** Like `isJsonObject`, but also false for an object whose own `constructor` key shadows `Object`. */
+export declare function isJsonObjectLiteral(value: JsonValue | undefined): value is {
+    [key: string]: JsonValue;
+};
+/** Windows PowerShell 5.1 saves JSON with a UTF-8 byte order mark that JSON.parse rejects, so one leading mark is dropped. */
+export declare function readJsonFile(file: string): JsonValue;
+//# sourceMappingURL=json.d.ts.map

package/dist/util/json.js

@@ -0,0 +1,25 @@
+// Leaf module: the one value space JSON.parse can produce, so boundary guards narrow a shared type.
+import * as fs from 'fs';
+export function isJsonString(value) {
+    return typeof value === 'string';
+}
+export function isJsonNumber(value) {
+    return typeof value === 'number';
+}
+export function isJsonBoolean(value) {
+    return typeof value === 'boolean';
+}
+/** A non-null, non-array object. */
+export function isJsonObject(value) {
+    return value !== undefined && value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+/** Like `isJsonObject`, but also false for an object whose own `constructor` key shadows `Object`. */
+export function isJsonObjectLiteral(value) {
+    return value !== undefined && value !== null && !Array.isArray(value) && value.constructor === Object;
+}
+/** Windows PowerShell 5.1 saves JSON with a UTF-8 byte order mark that JSON.parse rejects, so one leading mark is dropped. */
+export function readJsonFile(file) {
+    const text = fs.readFileSync(file, 'utf8');
+    return JSON.parse(text.codePointAt(0) === 0xfeff ? text.slice(1) : text);
+}
+//# sourceMappingURL=json.js.map

package/dist/{log.d.ts → util/log.d.ts}

@@ -1,7 +1,8 @@
-/** Leveled stderr logger. `HIPPO_LOG` picks the threshold (error, warn, info, debug); unset or unknown means warn. */
+/** Leveled stderr logger. `HIPPO_LOG` picks the threshold (error, warn, info, debug); unset or unknown means warn. `HIPPO_LOG_FORMAT=json` writes JSON lines. */
 export type LogLevel = 'error' | 'warn' | 'info' | 'debug';
-/** Extra key=value pairs appended to the line; `requestId` ties a line to one HTTP request. */
+/** Extra key=value pairs appended to the line. `ts` and, inside a request, `requestId` are added to every line written. */
 export interface LogFields {
+    ts?: string;
     requestId?: string;
     [key: string]: string | number | boolean | undefined;
 }
@@ -10,6 +11,8 @@ export declare function logThreshold(): LogLevel;
 export declare function isLevelEnabled(level: LogLevel): boolean;
 /** Same `[hippo] ` prefix the existing stderr lines use, so default-level output reads as before. */
 export declare function formatLogLine(level: LogLevel, message: string, fields?: LogFields): string;
+/** One JSON object per line for a log collector; JSON escaping keeps a multi-line value on the one line. */
+export declare function formatLogJson(level: LogLevel, message: string, fields?: LogFields): string;
 /** Write `message` at `level` the first time `key` is seen in this process; later calls are dropped. */
 declare function once(key: string, level: LogLevel, message: string, fields?: LogFields): void;
 /** Warn the first time `key` is seen in this process, then log at debug, so a repeating failure stays findable without flooding stderr. */

package/dist/{log.js → util/log.js}

@@ -1,5 +1,6 @@
-/** Leveled stderr logger. `HIPPO_LOG` picks the threshold (error, warn, info, debug); unset or unknown means warn. */
-import { envLogLevel } from './env.js';
+/** Leveled stderr logger. `HIPPO_LOG` picks the threshold (error, warn, info, debug); unset or unknown means warn. `HIPPO_LOG_FORMAT=json` writes JSON lines. */
+import { envLogJson, envLogLevel } from './env.js';
+import { currentRequestId } from './request-scope.js';
 const RANK = { error: 0, warn: 1, info: 2, debug: 3 };
 function isLogLevel(value) {
     return Object.hasOwn(RANK, value);
@@ -22,10 +23,18 @@ export function formatLogLine(level, message, fields = {}) {
         .join('');
     return `[hippo] ${level}: ${oneLine(message)}${extras}`;
 }
+/** One JSON object per line for a log collector; JSON escaping keeps a multi-line value on the one line. */
+export function formatLogJson(level, message, fields = {}) {
+    const { ts, ...rest } = fields;
+    return JSON.stringify({ ts, level, msg: message, ...rest });
+}
 function write(level, message, fields) {
     if (!isLevelEnabled(level))
         return;
-    process.stderr.write(`${formatLogLine(level, message, fields)}\n`);
+    // The request id is ambient, so a line logged deep in a library call still names the request it ran for.
+    const stamped = { ts: new Date().toISOString(), requestId: currentRequestId(), ...fields };
+    const format = envLogJson() ? formatLogJson : formatLogLine;
+    process.stderr.write(`${format(level, message, stamped)}\n`);
 }
 const onceKeys = new Set();
 /** Write `message` at `level` the first time `key` is seen in this process; later calls are dropped. */

package/dist/util/real-path.d.ts

@@ -0,0 +1,3 @@
+/** Dereferences symlinks and junctions and normalises case on Windows; falls back to path.resolve when the path does not exist yet. */
+export declare function realpathOrResolve(p: string): string;
+//# sourceMappingURL=real-path.d.ts.map

package/dist/util/real-path.js

@@ -0,0 +1,15 @@
+// Leaf module: path canonicalisation shared by project identity and the importers.
+import * as fs from 'fs';
+import * as path from 'path';
+import { errorMessage, log } from './log.js';
+/** Dereferences symlinks and junctions and normalises case on Windows; falls back to path.resolve when the path does not exist yet. */
+export function realpathOrResolve(p) {
+    try {
+        return fs.realpathSync.native(p);
+    }
+    catch (err) {
+        log.debug(`realpath fell back to resolve for ${p}: ${errorMessage(err)}`);
+        return path.resolve(p);
+    }
+}
+//# sourceMappingURL=real-path.js.map

package/dist/util/request-scope.d.ts

@@ -0,0 +1,27 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+/** What every scope carries; the store layer's RequestStores is one, and adds its handles. */
+export interface RequestScope {
+    /** Ties every log line written inside the scope to one request. */
+    readonly requestId: string | undefined;
+    /** Set for a served request that must be answered by a given time. */
+    readonly deadline?: RequestDeadline | undefined;
+}
+/** When a request must be answered, and the store calls it still waits on: the store ends each of those soon after `at`, with the outcome only it knows. */
+export declare class RequestDeadline {
+    #private;
+    /** Epoch milliseconds. */
+    readonly at: number;
+    constructor(at: number);
+    /** Counts `call` as one the request waits on until it settles. */
+    track<T>(call: Promise<T>): Promise<T>;
+    /** Runs `fn` now, or once the last store call the request waits on has settled. */
+    onceIdle(fn: () => void): void;
+}
+export declare const requestScopes: AsyncLocalStorage<RequestScope>;
+/** The id of the request this code runs for, if any. */
+export declare function currentRequestId(): string | undefined;
+/** The deadline of the request this code runs for, if it has one. */
+export declare function currentDeadline(): RequestDeadline | undefined;
+/** Runs `fn` with `requestId` on every log line it writes, including the ones from timers and promises it starts. `deadline` reaches every store call made inside. */
+export declare function runWithRequestId<T>(requestId: string, fn: () => T, deadline?: RequestDeadline): T;
+//# sourceMappingURL=request-scope.d.ts.map

package/dist/util/request-scope.js

@@ -0,0 +1,47 @@
+// The one ambient scope of a request. A leaf module, so the logger can read the request id without importing the store layer.
+import { AsyncLocalStorage } from 'node:async_hooks';
+/** When a request must be answered, and the store calls it still waits on: the store ends each of those soon after `at`, with the outcome only it knows. */
+export class RequestDeadline {
+    /** Epoch milliseconds. */
+    at;
+    #storeCalls = 0;
+    #whenIdle;
+    constructor(at) {
+        this.at = at;
+    }
+    /** Counts `call` as one the request waits on until it settles. */
+    track(call) {
+        this.#storeCalls += 1;
+        const done = () => {
+            this.#storeCalls -= 1;
+            if (this.#storeCalls > 0)
+                return;
+            const idle = this.#whenIdle;
+            this.#whenIdle = undefined;
+            idle?.();
+        };
+        call.then(done, done);
+        return call;
+    }
+    /** Runs `fn` now, or once the last store call the request waits on has settled. */
+    onceIdle(fn) {
+        if (this.#storeCalls === 0)
+            fn();
+        else
+            this.#whenIdle = fn;
+    }
+}
+export const requestScopes = new AsyncLocalStorage();
+/** The id of the request this code runs for, if any. */
+export function currentRequestId() {
+    return requestScopes.getStore()?.requestId;
+}
+/** The deadline of the request this code runs for, if it has one. */
+export function currentDeadline() {
+    return requestScopes.getStore()?.deadline;
+}
+/** Runs `fn` with `requestId` on every log line it writes, including the ones from timers and promises it starts. `deadline` reaches every store call made inside. */
+export function runWithRequestId(requestId, fn, deadline) {
+    return requestScopes.run({ requestId, deadline }, fn);
+}
+//# sourceMappingURL=request-scope.js.map

package/dist/{same-text.d.ts → util/same-text.d.ts}

@@ -1,4 +1,4 @@
-import type { MemoryEntry } from './memory.js';
+import type { MemoryEntry } from '../core/memory.js';
 type Text = Pick<MemoryEntry, 'content'> & {
     source?: string;
     pinned?: boolean;

package/dist/{secret-detect.js → util/secret-detect.js}

@@ -26,10 +26,11 @@ const SECRET_PATTERNS = [
     { name: 'aws-access-key', re: /\bAKIA[0-9A-Z]{16}\b/ },
     { name: 'github-token', re: /\b(?:ghp|gho|ghu|ghs|ghr)_[A-Za-z0-9]{36}\b/ },
     { name: 'github-fine-grained-pat', re: /\bgithub_pat_[A-Za-z0-9_]{22,}\b/ },
-    { name: 'slack-token', re: /\bxox[baprs]-[A-Za-z0-9-]{10,}\b/ },
+    // A token may end in a hyphen, where `\b` holds only before a word character: a class that holds `-` runs to its end, and a fixed length may also close on a hyphen.
+    { name: 'slack-token', re: /\bxox[baprs]-[A-Za-z0-9-]{10,}/ },
     { name: 'stripe-key', re: /\b[sr]k_(?:live|test)_[A-Za-z0-9]{16,}\b/ },
-    { name: 'google-api-key', re: /\bAIza[0-9A-Za-z_-]{35}\b/ },
-    // hk_ is hippo's own API key (src/auth.ts); npm, Hugging Face, GitLab and Slack webhook shapes follow gitleaks' rules.
+    { name: 'google-api-key', re: /\bAIza[0-9A-Za-z_-]{35}(?:\b|(?<=-))/ },
+    // hk_ is hippo's own API key (src/store/auth.ts); npm, Hugging Face, GitLab and Slack webhook shapes follow gitleaks' rules.
     { name: 'hippo-api-key', re: /\bhk_[a-z2-7]{24}\.[a-z2-7]{32}\b/ },
     { name: 'npm-token', re: /\bnpm_[A-Za-z0-9]{36}\b/ },
     { name: 'huggingface-token', re: /\bhf_[A-Za-z]{34}\b/ },
@@ -42,7 +43,7 @@ const SECRET_PATTERNS = [
     // like "the sk- prefix identifies API keys" without an actual long token
     // does not flag, but a stored key ("prod API key sk_live_...")
     // does.
-    { name: 'sk-style-key', re: /\bsk-[A-Za-z0-9_-]{20,}\b/ },
+    { name: 'sk-style-key', re: /\bsk-[A-Za-z0-9_-]{20,}/ },
     { name: 'sk-underscore-key', re: /\bsk_[A-Za-z0-9]+_[A-Za-z0-9_]{6,}\b/ },
     // The value needs 12+ token-safe chars and a digit, or `token = estimateTokens(...)` and doc templates like user:password@ would hide code lessons from ambient context.
     // Secret names end in the keyword (dbPassword, PGPASSWORD) and token_url does not, so the match opens there and scans no prefix; pwd and pass need a _ as OLDPWD and bypass are not secrets.

package/dist/util/stored-json.d.ts

@@ -0,0 +1,9 @@
+/** Where the value lives. The value itself is never logged: it is caller-written text. */
+export interface StoredJsonSite {
+    table: string;
+    id: string | number;
+    column: string;
+}
+/** Warns the first time this row's column is found damaged, then logs at debug, so a row read on every recall cannot flood stderr. */
+export declare function warnDamagedColumn(site: StoredJsonSite, problem: 'not valid JSON' | 'wrong shape'): void;
+//# sourceMappingURL=stored-json.d.ts.map

package/dist/util/stored-json.js

@@ -0,0 +1,8 @@
+// One log line for a stored JSON column that will not read, so a reader that degrades to an empty value still leaves a trace.
+import { log } from './log.js';
+/** Warns the first time this row's column is found damaged, then logs at debug, so a row read on every recall cannot flood stderr. */
+export function warnDamagedColumn(site, problem) {
+    const { table, id, column } = site;
+    log.warnThenDebug(`damaged-column:${table}:${id}:${column}`, `store: ${table}.${column} is ${problem}; read as empty`, { table, id, column });
+}
+//# sourceMappingURL=stored-json.js.map

package/dist/util/time.d.ts

@@ -0,0 +1,2 @@
+export declare const DAY_MS = 86400000;
+//# sourceMappingURL=time.d.ts.map

package/dist/util/time.js

@@ -0,0 +1,3 @@
+// Durations in the base layer, so no layer imports a higher one for a constant.
+export const DAY_MS = 86_400_000;
+//# sourceMappingURL=time.js.map

package/dist/util/token-text.d.ts

@@ -0,0 +1,18 @@
+/** Hex characters kept from a SHA-256 when it fingerprints a block, key or turn. */
+export declare const FINGERPRINT_HEX_CHARS = 16;
+/** Hex characters kept from a hash or UUID to build a short id. */
+export declare const ID_SUFFIX_CHARS = 12;
+/** Characters of a rejected-value or tombstone digest shown to a person. */
+export declare const DIGEST_DISPLAY_CHARS = 12;
+/** Length of the YYYY-MM-DD head of an ISO timestamp. */
+export declare const DATE_PREFIX_CHARS = 10;
+/** Characters of memory content shown as a one-line preview. */
+export declare const CONTENT_PREVIEW_CHARS = 80;
+/**
+ * Rough token estimate: characters / 4. The single estimate behind every
+ * token budget and ledger count in hippo.
+ */
+export declare function estimateTokens(text: string): number;
+/** Stable 16-hex-char hash of a rendered block, for change detection. */
+export declare function blockHash(text: string): string;
+//# sourceMappingURL=token-text.d.ts.map

package/dist/util/token-text.js

@@ -0,0 +1,23 @@
+import { createHash } from 'node:crypto';
+/** Hex characters kept from a SHA-256 when it fingerprints a block, key or turn. */
+export const FINGERPRINT_HEX_CHARS = 16;
+/** Hex characters kept from a hash or UUID to build a short id. */
+export const ID_SUFFIX_CHARS = 12;
+/** Characters of a rejected-value or tombstone digest shown to a person. */
+export const DIGEST_DISPLAY_CHARS = 12;
+/** Length of the YYYY-MM-DD head of an ISO timestamp. */
+export const DATE_PREFIX_CHARS = 10;
+/** Characters of memory content shown as a one-line preview. */
+export const CONTENT_PREVIEW_CHARS = 80;
+/**
+ * Rough token estimate: characters / 4. The single estimate behind every
+ * token budget and ledger count in hippo.
+ */
+export function estimateTokens(text) {
+    return Math.ceil(text.length / 4);
+}
+/** Stable 16-hex-char hash of a rendered block, for change detection. */
+export function blockHash(text) {
+    return createHash('sha256').update(text).digest('hex').slice(0, FINGERPRINT_HEX_CHARS);
+}
+//# sourceMappingURL=token-text.js.map

package/dist/{version.d.ts → util/version.d.ts}

@@ -16,7 +16,7 @@
  * an ESM `import` can resolve cleanly, and a hardcoded constant survives
  * any packager that drops .json files.
  */
-export declare const PACKAGE_VERSION = "1.68.0";
+export declare const PACKAGE_VERSION = "1.70.0";
 /** The floor a store takes on its first expiring key: the first release with schema v53, set by hand in that release; scripts/check-expiring-keys-floor.mjs gates it. */
 export declare const EXPIRING_KEYS_MIN_BINARY = "1.64.0";
 /** The floor a store takes on its first session bind or owner snapshot: first release with v54; set by hand in that release. */

package/dist/{version.js → util/version.js}

@@ -16,7 +16,7 @@
  * an ESM `import` can resolve cleanly, and a hardcoded constant survives
  * any packager that drops .json files.
  */
-export const PACKAGE_VERSION = '1.68.0';
+export const PACKAGE_VERSION = '1.70.0';
 /** The floor a store takes on its first expiring key: the first release with schema v53, set by hand in that release; scripts/check-expiring-keys-floor.mjs gates it. */
 export const EXPIRING_KEYS_MIN_BINARY = '1.64.0';
 /** The floor a store takes on its first session bind or owner snapshot: first release with v54; set by hand in that release. */

package/extensions/openclaw-plugin/index.ts

@@ -294,12 +294,8 @@ export default function register(api: any) {
     async execute(_id: string, params: { query: string; budget?: number }) {
       const cfg = getConfig(api);
       const budget = params.budget ?? cfg.budget ?? 1500;
-      const framing = cfg.framing ?? 'observe';
       const hippoCwd = resolveHippoCwdFromContext(api, ctx, cfg.root);
-      const result = runHippo(
-        ['recall', params.query, '--budget', String(budget), '--framing', framing],
-        hippoCwd,
-      );
+      const result = runHippo(['recall', params.query, '--budget', String(budget)], hippoCwd);
       return { content: [{ type: 'text', text: result || 'No relevant memories found.' }] };
     },
   }));

package/extensions/openclaw-plugin/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "hippo-memory",
   "name": "Hippo Memory",
   "description": "Make your agent's memory work like a brain. Hippo is long-term memory for coding agents.",
-  "version": "1.68.0",
+  "version": "1.70.0",
 
   "configSchema": {
     "type": "object",

package/extensions/openclaw-plugin/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hippo-memory",
-  "version": "1.68.0",
+  "version": "1.70.0",
   "type": "module",
   "description": "Make your agent's memory work like a brain. Hippo is long-term memory for coding agents.",
   "main": "index.ts",

package/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "hippo-memory",
   "name": "Hippo Memory",
   "description": "Make your agent's memory work like a brain. Hippo is long-term memory for coding agents.",
-  "version": "1.68.0",
+  "version": "1.70.0",
   "configSchema": {
     "type": "object",
     "additionalProperties": false,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hippo-memory",
-  "version": "1.68.0",
+  "version": "1.70.0",
   "description": "Make your agent's memory work like a brain. Hippo is long-term memory for coding agents.",
   "mcpName": "io.github.kitfunso/hippo-memory",
   "type": "module",
@@ -43,7 +43,7 @@
     "test:eval": "vitest run --config vitest.eval.config.ts",
     "lint": "oxlint",
     "sbom": "node scripts/sbom.mjs",
-    "audit:security": "npm audit --audit-level=high && npm --prefix ui audit --audit-level=high",
+    "audit:security": "npm audit --audit-level=moderate && npm --prefix ui audit --audit-level=moderate",
     "postinstall": "node scripts/postinstall.cjs",
     "smoke:pack": "node scripts/smoke-pack.mjs",
     "smoke:openclaw-install": "node scripts/smoke-openclaw-install.mjs",

package/dist/api.d.ts

@@ -1,26 +0,0 @@
-export { ApiError, BadRequestError, ConflictError, ForbiddenError, NotFoundError } from './api-errors.js';
-export { isPrivateScope, passesScopeFilterForRecall } from './recall-scope.js';
-export { passesCliRecallScopeFilter, ScopeForbiddenError } from './recall-scope.js';
-export type { TokenSummary, TokenSurface, TokenSurfaceSummary } from './token-ledger.js';
-export type { FailureSummary } from './failure-log.js';
-export { classifyOriginProject } from './project-identity.js';
-export * from './api/types.js';
-export * from './api/remember.js';
-export * from './api/recall-types.js';
-export * from './api/recall.js';
-export * from './api/assemble.js';
-export * from './api/drill-down.js';
-export * from './api/outcome.js';
-export * from './api/forget.js';
-export * from './api/promote.js';
-export * from './api/auth.js';
-export * from './api/audit.js';
-export * from './api/context-types.js';
-export * from './api/context.js';
-export * from './api/tokens.js';
-export * from './api/dormant.js';
-export * from './api/quarantine.js';
-export * from './api/sleep.js';
-export * from './api/goals.js';
-export * from './api/learn.js';
-//# sourceMappingURL=api.d.ts.map

package/dist/api.js

@@ -1,29 +0,0 @@
-// Domain API layer: Context-taking functions that the CLI, the HTTP server and MCP all call, so the
-// business logic lives in one place. The code lives in src/api/, one module per domain; this barrel
-// keeps every import path that callers already use.
-export { ApiError, BadRequestError, ConflictError, ForbiddenError, NotFoundError } from './api-errors.js';
-// The recall-side scope predicates live in recall-scope.ts (leaf) so shared.ts can use them without an import cycle.
-export { isPrivateScope, passesScopeFilterForRecall } from './recall-scope.js';
-export { passesCliRecallScopeFilter, ScopeForbiddenError } from './recall-scope.js';
-// classifyOriginProject lives in project-identity.ts (leaf) for the same reason.
-export { classifyOriginProject } from './project-identity.js';
-export * from './api/types.js';
-export * from './api/remember.js';
-export * from './api/recall-types.js';
-export * from './api/recall.js';
-export * from './api/assemble.js';
-export * from './api/drill-down.js';
-export * from './api/outcome.js';
-export * from './api/forget.js';
-export * from './api/promote.js';
-export * from './api/auth.js';
-export * from './api/audit.js';
-export * from './api/context-types.js';
-export * from './api/context.js';
-export * from './api/tokens.js';
-export * from './api/dormant.js';
-export * from './api/quarantine.js';
-export * from './api/sleep.js';
-export * from './api/goals.js';
-export * from './api/learn.js';
-//# sourceMappingURL=api.js.map

package/dist/capture-contract.js

@@ -1,49 +0,0 @@
-// The shared shape every agent adapter turns a host payload into, so capture code is written once for all runtimes.
-// Field meanings, statuses and how to add a runtime: docs/integrations/agent-inventory.md.
-/** A string guard that avoids `typeof`; it matches it for every value `JSON.parse` can produce. */
-export function isStringValue(value) {
-    return String(value) === value;
-}
-/** An object guard that avoids `typeof`; arrays count as objects, as they do for `typeof`. */
-export function isObjectLike(value) {
-    return value !== null && value instanceof Object;
-}
-/** Reads a Claude Code PreCompact payload, or a Copilot one after stdin.ts mapped it to the same snake_case keys; only an empty stdin counts as a manual run. */
-export function readClaudeCodePreCompact(stdinText, timedOut, runtime = 'claude-code') {
-    const empty = !stdinText || stdinText.trim() === '';
-    if (timedOut && empty) {
-        return { status: 'unavailable', reason: 'no PreCompact payload arrived before the stdin wait window closed' };
-    }
-    const base = { runtime, event: 'pre-compact' };
-    if (empty) {
-        return { status: 'received', input: { ...base, manual: true, sessionId: null, cwd: null, transcriptPath: null, trigger: null } };
-    }
-    let payload;
-    try {
-        payload = JSON.parse(stdinText.trim());
-    }
-    catch {
-        // Non-JSON stdin leaves payload undefined, which the shape check rejects like an explicit null.
-    }
-    // A bad payload is skipped, never treated as manual: discovery could pick up another session's transcript.
-    if (!isObjectLike(payload) || !('transcript_path' in payload) || !isStringValue(payload.transcript_path)) {
-        return { status: 'skipped', reason: 'malformed or incomplete PreCompact payload (missing string transcript_path)' };
-    }
-    const transcriptPath = payload.transcript_path;
-    // Path shape only: CLAUDE_CONFIG_DIR can move the transcript root, and a same-user process can already read every transcript.
-    if (!/\.jsonl$/i.test(transcriptPath)) {
-        return { status: 'skipped', reason: `payload transcript_path is not a .jsonl file: ${transcriptPath}` };
-    }
-    return {
-        status: 'received',
-        input: {
-            ...base,
-            manual: false,
-            sessionId: 'session_id' in payload && isStringValue(payload.session_id) ? payload.session_id : null,
-            cwd: 'cwd' in payload && isStringValue(payload.cwd) ? payload.cwd : null,
-            transcriptPath,
-            trigger: 'trigger' in payload && isStringValue(payload.trigger) ? payload.trigger : null,
-        },
-    };
-}
-//# sourceMappingURL=capture-contract.js.map

package/dist/connectors/github/idempotency.d.ts

@@ -1,19 +0,0 @@
-import type { DatabaseSyncLike } from '../../db.js';
-/**
- * Thrown by ingest's afterWrite hook when a concurrent worker has already
- * inserted github_event_log for the same idempotency_key. Roll back the
- * SAVEPOINT so exactly one memory row exists per key.
- */
-export declare class DuplicateIdempotencyError extends Error {
-    readonly idempotencyKey: string;
-    constructor(idempotencyKey: string);
-}
-export declare function hasSeenKey(db: DatabaseSyncLike, idempotencyKey: string): boolean;
-export declare function markKeySeen(db: DatabaseSyncLike, args: {
-    idempotencyKey: string;
-    deliveryId: string;
-    eventName: string;
-    memoryId: string | null;
-}): void;
-export declare function lookupMemoryByKey(db: DatabaseSyncLike, idempotencyKey: string): string | null;
-//# sourceMappingURL=idempotency.d.ts.map

package/dist/connectors/github/idempotency.js

@@ -1,27 +0,0 @@
-/**
- * Thrown by ingest's afterWrite hook when a concurrent worker has already
- * inserted github_event_log for the same idempotency_key. Roll back the
- * SAVEPOINT so exactly one memory row exists per key.
- */
-export class DuplicateIdempotencyError extends Error {
-    idempotencyKey;
-    constructor(idempotencyKey) {
-        super(`duplicate github idempotency_key: ${idempotencyKey}`);
-        this.name = 'DuplicateIdempotencyError';
-        this.idempotencyKey = idempotencyKey;
-    }
-}
-export function hasSeenKey(db, idempotencyKey) {
-    const row = db.prepare(`SELECT 1 FROM github_event_log WHERE idempotency_key = ?`).get(idempotencyKey);
-    return !!row;
-}
-export function markKeySeen(db, args) {
-    db.prepare(`INSERT OR IGNORE INTO github_event_log (idempotency_key, delivery_id, event_name, ingested_at, memory_id) VALUES (?, ?, ?, ?, ?)`).run(args.idempotencyKey, args.deliveryId, args.eventName, new Date().toISOString(), args.memoryId);
-}
-export function lookupMemoryByKey(db, idempotencyKey) {
-    // SAFETY: the row comes from the SELECT above, which projects exactly the
-    // memory_id column of github_event_log.
-    const row = db.prepare(`SELECT memory_id FROM github_event_log WHERE idempotency_key = ?`).get(idempotencyKey);
-    return row?.memory_id ?? null;
-}
-//# sourceMappingURL=idempotency.js.map