hippo-memory 1.44.0 → 1.46.0

package/dist/client.d.ts

@@ -1,9 +1,9 @@
 /**
  * HTTP client wrapper for `hippo serve`.
  *
- * Mirrors the function signatures in src/api.ts so the CLI can route through
- * either path uniformly. Each function takes (serverUrl, apiKey?, ...) and
- * returns the same shape that api.ts would.
+ * Only the writes the CLI routes (remember, forget, archive, promote), which are
+ * also all HIPPO_REQUIRE_SERVER covers; every other command opens the store
+ * directly. Each call returns the same shape that api.ts would.
  *
  * Errors from the server (4xx/5xx) are mapped back into thrown Errors with
  * the server's `error` message preserved verbatim so existing CLI handlers
@@ -13,9 +13,7 @@
  * Network errors (ECONNREFUSED on a stale pidfile, etc.) propagate as the
  * native fetch failure so the caller can detect them and self-heal.
  */
-import type { AuditEvent } from './audit.js';
-import type { ApiKeyListItem } from './auth.js';
-import type { RememberOpts, RememberResult, RecallOpts, RecallResult, AuthCreateOpts, AuthCreateResult, AuditListOpts } from './api.js';
+import type { RememberOpts, RememberResult } from './api.js';
 /** An error the server answered with, not one the transport raised. The
  *  refused-connection classifier sniffs message text, and a server message
  *  quotes the caller's own id or content back verbatim. */
@@ -24,7 +22,6 @@ export declare class HttpResponseError extends Error {
     constructor(message: string, status: number);
 }
 export declare function remember(serverUrl: string, apiKey: string | undefined, opts: RememberOpts): Promise<RememberResult>;
-export declare function recall(serverUrl: string, apiKey: string | undefined, opts: RecallOpts): Promise<RecallResult>;
 export declare function forget(serverUrl: string, apiKey: string | undefined, id: string): Promise<{
     ok: true;
     id: string;
@@ -34,24 +31,10 @@ export declare function promote(serverUrl: string, apiKey: string | undefined, i
     sourceId: string;
     globalId: string;
 }>;
-export declare function supersede(serverUrl: string, apiKey: string | undefined, oldId: string, newContent: string): Promise<{
-    ok: true;
-    oldId: string;
-    newId: string;
-}>;
 export declare function archiveRaw(serverUrl: string, apiKey: string | undefined, id: string, reason: string): Promise<{
     ok: true;
     archivedAt: string;
 }>;
-export declare function authCreate(serverUrl: string, apiKey: string | undefined, opts: AuthCreateOpts): Promise<AuthCreateResult>;
-export declare function authList(serverUrl: string, apiKey: string | undefined, opts: {
-    active: boolean;
-}): Promise<ApiKeyListItem[]>;
-export declare function authRevoke(serverUrl: string, apiKey: string | undefined, keyId: string): Promise<{
-    ok: true;
-    revokedAt: string;
-}>;
-export declare function auditList(serverUrl: string, apiKey: string | undefined, opts: AuditListOpts): Promise<AuditEvent[]>;
 /**
  * How far a request got before the transport failed.
  *

package/dist/client.js

@@ -1,9 +1,9 @@
 /**
  * HTTP client wrapper for `hippo serve`.
  *
- * Mirrors the function signatures in src/api.ts so the CLI can route through
- * either path uniformly. Each function takes (serverUrl, apiKey?, ...) and
- * returns the same shape that api.ts would.
+ * Only the writes the CLI routes (remember, forget, archive, promote), which are
+ * also all HIPPO_REQUIRE_SERVER covers; every other command opens the store
+ * directly. Each call returns the same shape that api.ts would.
  *
  * Errors from the server (4xx/5xx) are mapped back into thrown Errors with
  * the server's `error` message preserved verbatim so existing CLI handlers
@@ -65,52 +65,6 @@ export async function remember(serverUrl, apiKey, opts) {
     const result = await res.json();
     return result;
 }
-export async function recall(serverUrl, apiKey, opts) {
-    const params = new URLSearchParams();
-    params.set('q', opts.query);
-    if (opts.limit !== undefined)
-        params.set('limit', String(opts.limit));
-    if (opts.mode !== undefined)
-        params.set('mode', opts.mode);
-    if (opts.scope !== undefined && opts.scope !== '')
-        params.set('scope', opts.scope);
-    if (opts.includeContinuity)
-        params.set('include_continuity', '1');
-    // v1.7.2 T4 — RecallOpts parity sweep. Pre-v1.7.2 the thin-client only
-    // serialized the five fields above; the HTTP server already accepted
-    // fresh_tail_count, fresh_tail_session_id, summarize_overflow. Adding
-    // scorer_window alone would have perpetuated the drift. Serializing all
-    // four together. Validation lives in api.recall(); transport just
-    // forwards.
-    if (opts.freshTailCount !== undefined)
-        params.set('fresh_tail_count', String(opts.freshTailCount));
-    if (opts.freshTailSessionId !== undefined && opts.freshTailSessionId !== '')
-        params.set('fresh_tail_session_id', opts.freshTailSessionId);
-    if (opts.summarizeOverflow !== undefined)
-        params.set('summarize_overflow', opts.summarizeOverflow ? '1' : '0');
-    if (opts.scorerWindow !== undefined)
-        params.set('scorer_window', String(opts.scorerWindow));
-    // v1.7.4 sessionId for dlPFC goal-stack boost + v0.33 / J1 sessionId
-    // for per-session anchoring ring. Pre-v0.33 the thin-client silently
-    // dropped opts.sessionId, so HTTP-routed SDK callers got no goal
-    // boost and (post-J1) the HTTP ring logged recall_anchor_skipped_no_session.
-    // Codex round-3 P2 catch: align serialization with the RecallOpts type.
-    // Note: opts.recallHistory is intentionally NOT serialized — it is an
-    // in-process snapshot only; the HTTP server maintains its own ring per
-    // sessionId, so passing recallHistory over the wire would be a no-op
-    // at best and a tenant-leak risk at worst.
-    if (opts.sessionId !== undefined && opts.sessionId !== '') {
-        params.set('session_id', opts.sessionId);
-    }
-    const res = await fetch(`${serverUrl}/v1/memories?${params.toString()}`, {
-        method: 'GET',
-        headers: buildHeaders(apiKey, false),
-    });
-    if (!res.ok)
-        await throwForStatus(res);
-    const result = await res.json();
-    return result;
-}
 export async function forget(serverUrl, apiKey, id) {
     const res = await fetch(`${serverUrl}/v1/memories/${encodeURIComponent(id)}`, {
         method: 'DELETE',
@@ -131,17 +85,6 @@ export async function promote(serverUrl, apiKey, id) {
     const result = await res.json();
     return result;
 }
-export async function supersede(serverUrl, apiKey, oldId, newContent) {
-    const res = await fetch(`${serverUrl}/v1/memories/${encodeURIComponent(oldId)}/supersede`, {
-        method: 'POST',
-        headers: buildHeaders(apiKey, true),
-        body: JSON.stringify({ content: newContent }),
-    });
-    if (!res.ok)
-        await throwForStatus(res);
-    const result = await res.json();
-    return result;
-}
 export async function archiveRaw(serverUrl, apiKey, id, reason) {
     const res = await fetch(`${serverUrl}/v1/memories/${encodeURIComponent(id)}/archive`, {
         method: 'POST',
@@ -153,58 +96,6 @@ export async function archiveRaw(serverUrl, apiKey, id, reason) {
     const result = await res.json();
     return result;
 }
-export async function authCreate(serverUrl, apiKey, opts) {
-    const res = await fetch(`${serverUrl}/v1/auth/keys`, {
-        method: 'POST',
-        headers: buildHeaders(apiKey, true),
-        body: JSON.stringify(opts),
-    });
-    if (!res.ok)
-        await throwForStatus(res);
-    const result = await res.json();
-    return result;
-}
-export async function authList(serverUrl, apiKey, opts) {
-    const params = new URLSearchParams();
-    params.set('active', opts.active ? 'true' : 'false');
-    const res = await fetch(`${serverUrl}/v1/auth/keys?${params.toString()}`, {
-        method: 'GET',
-        headers: buildHeaders(apiKey, false),
-    });
-    if (!res.ok)
-        await throwForStatus(res);
-    const result = await res.json();
-    return result;
-}
-export async function authRevoke(serverUrl, apiKey, keyId) {
-    const res = await fetch(`${serverUrl}/v1/auth/keys/${encodeURIComponent(keyId)}`, {
-        method: 'DELETE',
-        headers: buildHeaders(apiKey, false),
-    });
-    if (!res.ok)
-        await throwForStatus(res);
-    const result = await res.json();
-    return result;
-}
-export async function auditList(serverUrl, apiKey, opts) {
-    const params = new URLSearchParams();
-    if (opts.op !== undefined)
-        params.set('op', opts.op);
-    if (opts.since !== undefined)
-        params.set('since', opts.since);
-    if (opts.limit !== undefined)
-        params.set('limit', String(opts.limit));
-    const qs = params.toString();
-    const url = qs.length > 0 ? `${serverUrl}/v1/audit?${qs}` : `${serverUrl}/v1/audit`;
-    const res = await fetch(url, {
-        method: 'GET',
-        headers: buildHeaders(apiKey, false),
-    });
-    if (!res.ok)
-        await throwForStatus(res);
-    const result = await res.json();
-    return result;
-}
 function hasObjectCause(e) {
     // Node's fs/net system errors (ECONNREFUSED, ECONNRESET) attach the syscall
     // code on a non-null object `cause`; the strict-equality checks below

package/dist/config.d.ts

@@ -62,6 +62,13 @@ export interface HippoConfig {
     pinnedInject: {
         enabled: boolean;
         budget: number;
+        /** Skip a block identical to the one already injected this session
+         *  (ROADMAP TE2). Default true. Needs a session id from the hook payload. */
+        skipUnchanged: boolean;
+        /** Resend an unchanged block after this many consecutive skips, so long
+         *  sessions still see pinned rules near the latest turn. Default 10; 0
+         *  never resends an unchanged block. */
+        refreshTurns: number;
     };
     /** Memory scope isolation (v39): when true (default), ambient context
      *  (`hippo context`, the UserPromptSubmit hook, /v1/context, MCP
@@ -96,6 +103,19 @@ export interface HippoConfig {
     memoryValue: {
         enabled: boolean;
     };
+    /** Dormant memories (src/dormant.ts): when enabled (the default), the
+     *  sleep decay pass moves a memory that faded below the threshold into the
+     *  dormant store instead of deleting it. A dormant memory leaves recall and
+     *  context like a deleted one, but `hippo dormant restore <id>` brings it
+     *  back and `hippo dormant forget <id>` deletes it for good. A faded memory
+     *  the secret detector flags is always deleted, never kept dormant.
+     *  `{"enabled": false}` restores the old delete-on-fade behaviour. */
+    dormant: {
+        enabled: boolean;
+        /** Days a dormant memory is kept before sleep deletes it for good.
+         *  Default 180. 0 keeps dormant memories forever. */
+        retentionDays: number;
+    };
 }
 export declare function loadConfig(hippoRoot: string): HippoConfig;
 export declare function saveConfig(hippoRoot: string, config: HippoConfig): void;

package/dist/config.js

@@ -4,8 +4,9 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import { DEFAULT_PHYSICS_CONFIG, mergePhysicsConfig } from './physics-config.js';
+import { DEFAULT_HALF_LIFE_DAYS } from './memory.js';
 const DEFAULT_CONFIG = {
-    defaultHalfLifeDays: 7,
+    defaultHalfLifeDays: DEFAULT_HALF_LIFE_DAYS,
     defaultBudget: 4000,
     defaultContextBudget: 3000,
     decayBasis: 'adaptive',
@@ -44,6 +45,8 @@ const DEFAULT_CONFIG = {
     pinnedInject: {
         enabled: true,
         budget: 1500,
+        skipUnchanged: true,
+        refreshTurns: 10,
     },
     contextProjectIsolation: true,
     extraction: {
@@ -66,10 +69,17 @@ const DEFAULT_CONFIG = {
     memoryValue: {
         enabled: false,
     },
+    dormant: {
+        enabled: true,
+        retentionDays: 180,
+    },
 };
 function isMemoryValueConfig(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
+function isDormantConfig(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
 export function loadConfig(hippoRoot) {
     const configPath = path.join(hippoRoot, 'config.json');
     if (!fs.existsSync(configPath))
@@ -92,6 +102,28 @@ export function loadConfig(hippoRoot) {
                 `(got ${JSON.stringify(memoryValueRaw)}) - using defaults.`);
         }
         const memoryValueOverride = memoryValueRaw !== undefined && isMemoryValueConfig(memoryValueRaw) ? memoryValueRaw : {};
+        // Same rule as memoryValue above: a malformed value never silently
+        // changes what sleep does. Anything but a real object / boolean / number
+        // warns and falls back to the default, which keeps faded memories.
+        const dormantRaw = raw.dormant;
+        if (dormantRaw !== undefined && !isDormantConfig(dormantRaw)) {
+            console.error(`Warning: config.json's "dormant" must be an object like {"enabled": false} ` +
+                `(got ${JSON.stringify(dormantRaw)}) - using the default (faded memories kept dormant).`);
+        }
+        const dormantOverride = dormantRaw !== undefined && isDormantConfig(dormantRaw) ? dormantRaw : {};
+        // Only a real boolean counts: {"enabled": "false"} is a truthy string.
+        let dormantEnabled = dormantOverride.enabled ?? DEFAULT_CONFIG.dormant.enabled;
+        if (dormantEnabled !== true && dormantEnabled !== false) {
+            console.error(`Warning: config.json's "dormant.enabled" must be true or false ` +
+                `(got ${JSON.stringify(dormantEnabled)}) - using the default (faded memories kept dormant).`);
+            dormantEnabled = DEFAULT_CONFIG.dormant.enabled;
+        }
+        let dormantRetentionDays = dormantOverride.retentionDays ?? DEFAULT_CONFIG.dormant.retentionDays;
+        if (!Number.isFinite(dormantRetentionDays) || dormantRetentionDays < 0) {
+            console.error(`Warning: config.json's "dormant.retentionDays" must be a number of days, 0 or more ` +
+                `(got ${JSON.stringify(dormantRetentionDays)}) - using ${DEFAULT_CONFIG.dormant.retentionDays}.`);
+            dormantRetentionDays = DEFAULT_CONFIG.dormant.retentionDays;
+        }
         return {
             defaultHalfLifeDays: raw.defaultHalfLifeDays ?? DEFAULT_CONFIG.defaultHalfLifeDays,
             defaultBudget: raw.defaultBudget ?? DEFAULT_CONFIG.defaultBudget,
@@ -119,6 +151,10 @@ export function loadConfig(hippoRoot) {
                 ...DEFAULT_CONFIG.memoryValue,
                 ...memoryValueOverride,
             },
+            dormant: {
+                enabled: dormantEnabled,
+                retentionDays: dormantRetentionDays,
+            },
         };
     }
     catch (err) {

package/dist/consolidate.d.ts

@@ -9,6 +9,12 @@
 export interface ConsolidationResult {
     decayed: number;
     removed: number;
+    /** Faded memories moved to the dormant store instead of deleted (config
+     *  `dormant.enabled`; src/dormant.ts). Always 0 when that is off. */
+    dormant: number;
+    /** Dormant memories deleted for good this sleep because they outlived
+     *  `dormant.retentionDays` without a restore. */
+    dormantExpired: number;
     merged: number;
     semanticCreated: number;
     replayed: number;
@@ -26,6 +32,8 @@ export interface ConsolidationResult {
     dryRun: boolean;
     details: string[];
     physicsSimulated: number;
+    /** Ids the decay pass removes (or would remove, under dryRun). */
+    removedIds?: string[];
 }
 /**
  * Run a full consolidation pass.
@@ -33,5 +41,6 @@ export interface ConsolidationResult {
 export declare function consolidate(hippoRoot: string, options?: {
     dryRun?: boolean;
     now?: Date;
+    fetcher?: typeof fetch;
 }): Promise<ConsolidationResult>;
 //# sourceMappingURL=consolidate.d.ts.map