hippo-memory 1.69.0 → 1.71.0

package/dist/{config.d.ts → core/config.d.ts}

@@ -19,10 +19,8 @@ export interface HippoConfig {
         enabled: boolean | 'auto';
         model: string;
         hybridWeight: number;
-        /** Embedding backend. 'local' (default) = zero-dependency transformers.js.
-         *  'openai' | 'voyage' | 'cohere' = opt-in API embedder; needs the provider's
-         *  API key in env (OPENAI_API_KEY / VOYAGE_API_KEY / COHERE_API_KEY).
-         *  See src/embedding-provider.ts. */
+        /** Embedding backend: 'local' (default) = zero-dependency transformers.js; 'openai' | 'voyage' | 'cohere' = opt-in API embedder needing the provider's
+         *  API key in env (OPENAI_API_KEY / VOYAGE_API_KEY / COHERE_API_KEY). See src/store/embeddings/provider.ts. */
         provider?: 'local' | 'openai' | 'voyage' | 'cohere';
         /** Optional API base-URL override (self-host / proxy). HTTPS only (localhost
          *  may use http). Ignored by the local provider. */
@@ -57,18 +55,15 @@ export interface HippoConfig {
     autoTraceCapture: boolean;
     /** Only promote sessions whose session_complete event is within N days. */
     autoTraceWindowDays: number;
-    /** Mid-session pinned-rule re-injection via the Claude Code UserPromptSubmit
-     *  hook. When enabled, pinned memories are re-injected each turn within the
-     *  given token budget. */
+    /** Mid-session pinned-rule re-injection through the UserPromptSubmit hook: pinned memories are re-injected each turn within the token budget. */
     pinnedInject: {
         enabled: boolean;
         budget: number;
         /** Skip a block identical to the one already injected this session
          *  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. */
+        /** 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). */
         refreshTurns: number;
         /** Gate the hook's backfill on the prompt's own content instead of the five
          *  newest memories. Default true: the same overlap for fewer tokens. */
@@ -84,13 +79,8 @@ export interface HippoConfig {
         /** FTS candidate pool size per store before gating. Default 100. */
         promptRecallCandidates: number;
     };
-    /** Memory scope isolation: when true (default), ambient context
-     *  (`hippo context`, the UserPromptSubmit hook, /v1/context, MCP
-     *  hippo_context) excludes memories owned by OTHER projects; explicit
-     *  recall is unaffected. Set false to disable the ORIGIN PARTITION only -
-     *  the secret veto is unconditional for ambient surfaces and no config or
-     *  flag re-includes secret-flagged rows (explicit recall still returns
-     *  them). */
+    /** Memory scope isolation (default true): ambient context (`hippo context`, the hook, /v1/context, MCP hippo_context) excludes OTHER projects' memories;
+     *  explicit recall is unaffected. False disables the ORIGIN PARTITION only: the secret veto is unconditional, and no flag re-includes secret-flagged rows. */
     contextProjectIsolation: boolean;
     extraction: {
         enabled: boolean | 'auto';
@@ -110,17 +100,12 @@ export interface HippoConfig {
         enabled: boolean;
     };
     /** Opt-in learned memory-value rescue veto on the sleep decay pass. Default OFF: the frozen weights
-     *  (src/memory-value-weights.ts) only run when enabled; the rescue budget is a code constant, not user-tunable. */
+     *  (src/consolidate/memory-value-weights.ts) only run when enabled; the rescue budget is a code constant, not user-tunable. */
     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 memories (src/store/dormant.ts), on by default: the sleep decay pass moves a memory that faded below the threshold there instead of deleting it
+     *  (`hippo dormant restore|forget <id>`); a faded memory the secret detector flags is always deleted. `{"enabled": false}` restores delete-on-fade. */
     dormant: {
         enabled: boolean;
         /** Days a dormant memory is kept before sleep deletes it for good.
@@ -136,12 +121,12 @@ export interface HippoConfig {
     agentMemories: {
         tools: string[] | null;
     };
-    /** Per-turn delivery ledger (src/recall-trace.ts): hashes, ids, counts and rejection reasons for each
+    /** Per-turn delivery ledger (src/store/recall-trace.ts): hashes, ids, counts and rejection reasons for each
      *  pinned-only context call. Default off; read from the store the token ledger writes to. */
     deliveryLedger: {
         enabled: boolean;
     };
-    /** Pilot holdout (src/pilot-arm.ts): share of sessions, in basis points 0-10000, that get no memories pushed.
+    /** Pilot holdout (src/api/pilot-arm.ts): share of sessions, in basis points 0-10000, that get no memories pushed.
      *  Default 0 = off. Read from the store the token ledger writes to. */
     pilot: {
         holdoutRateBp: number;
@@ -155,9 +140,10 @@ export interface HippoConfig {
      *  and a context read must name the caller's project. Default false. Read it through isSharedStore. */
     sharedStore: boolean;
 }
+export declare const DEFAULT_CONFIG: HippoConfig;
 export declare function loadConfig(hippoRoot: string): HippoConfig;
 /** True when the store's config.json sets `"sharedStore": true`. Once true, a root stays true for this process,
- *  so a broken edit while a server runs cannot turn it off. Reads only this key: loadConfig has no cache. */
+ *  so a broken edit while a server runs cannot turn it off. Reads only this key, so loadConfig's warnings stay loadConfig's. */
 export declare function isSharedStore(hippoRoot: string): boolean;
 /** Reads the root as shared for the rest of this process, whatever its config.json says. */
 export declare function markSharedStore(hippoRoot: string): void;

package/dist/{config.js → core/config.js}

@@ -5,9 +5,10 @@ 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';
-import { DEFAULT_LOCAL_BUMP, DEFAULT_RECALL_BUDGET } from './search/types.js';
-import { log } from './log.js';
-const DEFAULT_CONFIG = {
+import { DEFAULT_LOCAL_BUMP, DEFAULT_RECALL_BUDGET } from './search-types.js';
+import { errorMessage, log } from '../util/log.js';
+import { isJsonObject } from '../util/json.js';
+export const DEFAULT_CONFIG = {
     defaultHalfLifeDays: DEFAULT_HALF_LIFE_DAYS,
     defaultBudget: DEFAULT_RECALL_BUDGET,
     defaultContextBudget: 3000,
@@ -98,23 +99,11 @@ const DEFAULT_CONFIG = {
     },
     sharedStore: false,
 };
-function isMemoryValueConfig(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-function isDormantConfig(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-function isChurnStalenessConfig(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-function isDeliveryLedgerConfig(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
 // Only `{"enabled": true}` turns it on; anything malformed warns and stays off.
 function deliveryLedgerEnabled(value) {
     if (value === undefined)
         return false;
-    const isObject = isDeliveryLedgerConfig(value);
+    const isObject = isJsonObject(value);
     const enabled = isObject ? value.enabled : undefined;
     if (enabled === true || enabled === false)
         return enabled;
@@ -161,23 +150,22 @@ function memoryValueOverride(raw) {
     // Spreading a non-object raw.memoryValue (e.g. {"memoryValue": true}) silently leaves `enabled` false;
     // this feature must never be silently off, so warn loudly and fall back to defaults instead.
     const memoryValueRaw = raw.memoryValue;
-    const validMemoryValueConfig = memoryValueRaw === undefined || isMemoryValueConfig(memoryValueRaw);
+    const validMemoryValueConfig = memoryValueRaw === undefined || isJsonObject(memoryValueRaw);
     if (!validMemoryValueConfig) {
         log.warn(`config.json's "memoryValue" must be an object like {"enabled": true} ` +
             `(got ${JSON.stringify(memoryValueRaw)}) - using defaults.`);
     }
-    return memoryValueRaw !== undefined && isMemoryValueConfig(memoryValueRaw) ? memoryValueRaw : {};
+    return memoryValueRaw !== undefined && isJsonObject(memoryValueRaw) ? memoryValueRaw : {};
 }
 function dormantSettings(raw) {
-    // Same rule as memoryValue above: a malformed value never silently
-    // changes what sleep does. Anything but a real object / boolean / number
+    // 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)) {
+    if (dormantRaw !== undefined && !isJsonObject(dormantRaw)) {
         log.warn(`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 : {};
+    const dormantOverride = dormantRaw !== undefined && isJsonObject(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) {
@@ -196,12 +184,12 @@ function dormantSettings(raw) {
 function churnStalenessEnabled(raw) {
     // Same "never silently wrong" rule as memoryValue/dormant above.
     const churnStalenessRaw = raw.churnStaleness;
-    const validChurnStalenessConfig = churnStalenessRaw === undefined || isChurnStalenessConfig(churnStalenessRaw);
+    const validChurnStalenessConfig = churnStalenessRaw === undefined || isJsonObject(churnStalenessRaw);
     if (!validChurnStalenessConfig) {
         log.warn(`config.json's "churnStaleness" must be an object like {"enabled": true} ` +
             `(got ${JSON.stringify(churnStalenessRaw)}) - using defaults.`);
     }
-    const enabled = churnStalenessRaw !== undefined && isChurnStalenessConfig(churnStalenessRaw)
+    const enabled = churnStalenessRaw !== undefined && isJsonObject(churnStalenessRaw)
         ? churnStalenessRaw.enabled
         : DEFAULT_CONFIG.churnStaleness.enabled;
     if (enabled !== true && enabled !== false) {
@@ -230,63 +218,95 @@ function sharedStoreFlag(raw) {
     return false;
 }
 export function loadConfig(hippoRoot) {
-    const configPath = path.join(hippoRoot, 'config.json');
-    if (!fs.existsSync(configPath))
+    // A caller that names no folder, as an add-on serving another store does, gets the defaults, never the working folder's config.json.
+    if (hippoRoot === '')
         return { ...DEFAULT_CONFIG };
+    const configPath = path.join(hippoRoot, 'config.json');
+    const key = path.resolve(configPath);
+    const stamp = fileStamp(configPath);
+    const hit = parsedConfigs.get(key);
+    if (hit !== undefined && hit.stamp === stamp)
+        return { ...hit.config };
+    const config = stamp === null ? DEFAULT_CONFIG : parseConfigFile(configPath);
+    if (parsedConfigs.size >= PARSED_CONFIGS_MAX)
+        parsedConfigs.clear();
+    parsedConfigs.set(key, { stamp, config });
+    return { ...config };
+}
+const PARSED_CONFIGS_MAX = 64;
+// Each path's parsed config with the stamp of the file it came from, so an unchanged file costs one stat and no parse.
+const parsedConfigs = new Map();
+/** A file's mtime and size, which an edit changes; null when it is missing or cannot be reached, as existsSync answers false. */
+function fileStamp(file) {
+    try {
+        const stat = fs.statSync(file, { throwIfNoEntry: false });
+        return stat === undefined ? null : `${stat.mtimeMs}:${stat.size}`;
+    }
+    catch (err) {
+        log.debug(`config: ${file} could not be reached, read as missing: ${errorMessage(err)}`);
+        return null;
+    }
+}
+function parseConfigFile(configPath) {
     try {
         const raw = JSON.parse(fs.readFileSync(configPath, 'utf8'));
-        const basis = raw.decayBasis;
-        const validBasis = basis === 'clock' || basis === 'session' || basis === 'adaptive';
-        const memoryValue = memoryValueOverride(raw);
-        const dormant = dormantSettings(raw);
-        const churnEnabled = churnStalenessEnabled(raw);
-        const halfLifeDays = defaultHalfLifeDays(raw);
-        return {
-            defaultHalfLifeDays: halfLifeDays,
-            defaultBudget: raw.defaultBudget ?? DEFAULT_CONFIG.defaultBudget,
-            defaultContextBudget: raw.defaultContextBudget ?? DEFAULT_CONFIG.defaultContextBudget,
-            decayBasis: validBasis ? basis : DEFAULT_CONFIG.decayBasis,
-            autoLearnOnSleep: raw.autoLearnOnSleep ?? DEFAULT_CONFIG.autoLearnOnSleep,
-            autoShareOnSleep: raw.autoShareOnSleep ?? DEFAULT_CONFIG.autoShareOnSleep,
-            autoSleep: { ...DEFAULT_CONFIG.autoSleep, ...(raw.autoSleep ?? {}) },
-            embeddings: { ...DEFAULT_CONFIG.embeddings, ...(raw.embeddings ?? {}) },
-            global: { ...DEFAULT_CONFIG.global, ...(raw.global ?? {}) },
-            gitLearnPatterns: raw.gitLearnPatterns ?? DEFAULT_CONFIG.gitLearnPatterns,
-            physics: mergePhysicsConfig(raw.physics),
-            mmr: { ...DEFAULT_CONFIG.mmr, ...(raw.mmr ?? {}) },
-            search: { ...DEFAULT_CONFIG.search, ...(raw.search ?? {}) },
-            replay: { ...DEFAULT_CONFIG.replay, ...(raw.replay ?? {}) },
-            autoTraceCapture: raw.autoTraceCapture ?? DEFAULT_CONFIG.autoTraceCapture,
-            autoTraceWindowDays: raw.autoTraceWindowDays ?? DEFAULT_CONFIG.autoTraceWindowDays,
-            pinnedInject: { ...DEFAULT_CONFIG.pinnedInject, ...(raw.pinnedInject ?? {}) },
-            contextProjectIsolation: raw.contextProjectIsolation ?? DEFAULT_CONFIG.contextProjectIsolation,
-            extraction: { ...DEFAULT_CONFIG.extraction, ...(raw.extraction ?? {}) },
-            multihop: { ...DEFAULT_CONFIG.multihop, ...(raw.multihop ?? {}) },
-            salience: { ...DEFAULT_CONFIG.salience, ...(raw.salience ?? {}) },
-            ambient: { ...DEFAULT_CONFIG.ambient, ...(raw.ambient ?? {}) },
-            memoryValue: {
-                ...DEFAULT_CONFIG.memoryValue,
-                ...memoryValue,
-            },
-            dormant,
-            churnStaleness: {
-                enabled: churnEnabled,
-            },
-            agentMemories: { tools: agentMemoryTools(raw.agentMemories?.tools) },
-            deliveryLedger: { enabled: deliveryLedgerEnabled(raw.deliveryLedger) },
-            pilot: { holdoutRateBp: pilotHoldoutRate(raw.pilot) },
-            projectIdentity: { remote: projectIdentityRemote(raw.projectIdentity) },
-            sharedStore: sharedStoreFlag(raw),
-        };
+        return configOverDefaults(raw);
     }
     catch (err) {
         if (fs.existsSync(configPath)) {
-            log.warn(`failed to parse ${configPath}: ${err instanceof Error ? err.message : err}`);
+            log.warn(`failed to parse ${configPath}: ${errorMessage(err)}`);
         }
         return { ...DEFAULT_CONFIG };
     }
 }
+function configOverDefaults(raw) {
+    const basis = raw.decayBasis;
+    const validBasis = basis === 'clock' || basis === 'session' || basis === 'adaptive';
+    const memoryValue = memoryValueOverride(raw);
+    const dormant = dormantSettings(raw);
+    const churnEnabled = churnStalenessEnabled(raw);
+    const halfLifeDays = defaultHalfLifeDays(raw);
+    return {
+        defaultHalfLifeDays: halfLifeDays,
+        defaultBudget: raw.defaultBudget ?? DEFAULT_CONFIG.defaultBudget,
+        defaultContextBudget: raw.defaultContextBudget ?? DEFAULT_CONFIG.defaultContextBudget,
+        decayBasis: validBasis ? basis : DEFAULT_CONFIG.decayBasis,
+        autoLearnOnSleep: raw.autoLearnOnSleep ?? DEFAULT_CONFIG.autoLearnOnSleep,
+        autoShareOnSleep: raw.autoShareOnSleep ?? DEFAULT_CONFIG.autoShareOnSleep,
+        autoSleep: { ...DEFAULT_CONFIG.autoSleep, ...raw.autoSleep },
+        embeddings: { ...DEFAULT_CONFIG.embeddings, ...raw.embeddings },
+        global: { ...DEFAULT_CONFIG.global, ...raw.global },
+        gitLearnPatterns: raw.gitLearnPatterns ?? DEFAULT_CONFIG.gitLearnPatterns,
+        physics: mergePhysicsConfig(raw.physics),
+        mmr: { ...DEFAULT_CONFIG.mmr, ...raw.mmr },
+        search: { ...DEFAULT_CONFIG.search, ...raw.search },
+        replay: { ...DEFAULT_CONFIG.replay, ...raw.replay },
+        autoTraceCapture: raw.autoTraceCapture ?? DEFAULT_CONFIG.autoTraceCapture,
+        autoTraceWindowDays: raw.autoTraceWindowDays ?? DEFAULT_CONFIG.autoTraceWindowDays,
+        pinnedInject: { ...DEFAULT_CONFIG.pinnedInject, ...raw.pinnedInject },
+        contextProjectIsolation: raw.contextProjectIsolation ?? DEFAULT_CONFIG.contextProjectIsolation,
+        extraction: { ...DEFAULT_CONFIG.extraction, ...raw.extraction },
+        multihop: { ...DEFAULT_CONFIG.multihop, ...raw.multihop },
+        salience: { ...DEFAULT_CONFIG.salience, ...raw.salience },
+        ambient: { ...DEFAULT_CONFIG.ambient, ...raw.ambient },
+        memoryValue: {
+            ...DEFAULT_CONFIG.memoryValue,
+            ...memoryValue,
+        },
+        dormant,
+        churnStaleness: {
+            enabled: churnEnabled,
+        },
+        agentMemories: { tools: agentMemoryTools(raw.agentMemories?.tools) },
+        deliveryLedger: { enabled: deliveryLedgerEnabled(raw.deliveryLedger) },
+        pilot: { holdoutRateBp: pilotHoldoutRate(raw.pilot) },
+        projectIdentity: { remote: projectIdentityRemote(raw.projectIdentity) },
+        sharedStore: sharedStoreFlag(raw),
+    };
+}
 const sharedStoreRoots = new Set();
+// The stamp of each config.json last read as not shared: an unchanged file is not parsed again.
+const notSharedStamps = new Map();
 /** The folder as isGlobalStoreRoot compares it (realpath, case-folded on Windows); its helper sits behind an import cycle. */
 function sharedStoreKey(hippoRoot) {
     let real;
@@ -294,30 +314,35 @@ function sharedStoreKey(hippoRoot) {
         real = fs.realpathSync.native(hippoRoot);
     }
     catch (err) {
-        log.debug(`sharedStore: realpath fell back to resolve for ${hippoRoot}: ${err instanceof Error ? err.message : String(err)}`);
+        log.debug(`sharedStore: realpath fell back to resolve for ${hippoRoot}: ${errorMessage(err)}`);
         real = path.resolve(hippoRoot);
     }
     return process.platform === 'win32' ? real.toLowerCase() : real;
 }
 /** True when the store's config.json sets `"sharedStore": true`. Once true, a root stays true for this process,
- *  so a broken edit while a server runs cannot turn it off. Reads only this key: loadConfig has no cache. */
+ *  so a broken edit while a server runs cannot turn it off. Reads only this key, so loadConfig's warnings stay loadConfig's. */
 export function isSharedStore(hippoRoot) {
     const key = sharedStoreKey(hippoRoot);
     if (sharedStoreRoots.has(key))
         return true;
     const configPath = path.join(path.resolve(hippoRoot), 'config.json');
-    if (!fs.existsSync(configPath))
+    const stamp = fileStamp(configPath);
+    if (stamp === null || notSharedStamps.get(configPath) === stamp)
         return false;
     let raw;
     try {
         raw = JSON.parse(fs.readFileSync(configPath, 'utf8'));
     }
     catch (err) {
-        log.warn(`failed to read ${configPath}: ${err instanceof Error ? err.message : err} - sharedStore read as false.`);
+        log.warn(`failed to read ${configPath}: ${errorMessage(err)} - sharedStore read as false.`);
         return false;
     }
-    if (raw?.sharedStore !== true)
+    if (raw?.sharedStore !== true) {
+        if (notSharedStamps.size >= PARSED_CONFIGS_MAX)
+            notSharedStamps.clear();
+        notSharedStamps.set(configPath, stamp);
         return false;
+    }
     sharedStoreRoots.add(key);
     return true;
 }
@@ -328,5 +353,6 @@ export function markSharedStore(hippoRoot) {
 /** Test seam: forget every root seen as shared. */
 export function _resetSharedStoreCacheForTests() {
     sharedStoreRoots.clear();
+    notSharedStamps.clear();
 }
 //# sourceMappingURL=config.js.map

package/dist/{handoff.d.ts → core/handoff.d.ts}

@@ -1,10 +1,4 @@
-/**
- * Session handoff types and helpers.
- *
- * A handoff captures the state of a session so that a successor
- * session (or a different agent) can pick up where the previous
- * one left off.
- */
+/** Session handoff types and helpers: a handoff captures a session's state so a successor session or another agent can pick up where it left off. */
 /** Terminal state of a handoff's session, denormalized from its `session_complete` event. */
 export type HandoffOutcome = 'success' | 'failure' | 'partial';
 /** Best-effort evidence of repo state at handoff time; null fields mean collection failed or was skipped. */

package/dist/core/handoff.js

@@ -0,0 +1,81 @@
+/** Session handoff types and helpers: a handoff captures a session's state so a successor session or another agent can pick up where it left off. */
+import { isJsonString } from '../util/json.js';
+import { warnDamagedColumn } from '../util/stored-json.js';
+/** Narrows an unvalidated value (e.g. CLI input or event content) to a HandoffOutcome. */
+export function isHandoffOutcome(v) {
+    return v === 'success' || v === 'failure' || v === 'partial';
+}
+/** Renders evidence as one line shared by every renderer (CLI, MCP, token accounting). */
+export function formatHandoffEvidenceLine(evidence) {
+    const gitRef = evidence.gitRef ?? 'unknown';
+    const tree = evidence.dirtyTree === true ? 'dirty' : evidence.dirtyTree === false ? 'clean' : 'unknown';
+    const tests = evidence.testStatus ?? 'unknown';
+    return `git ${gitRef}, tree ${tree}, tests ${tests}`;
+}
+const TEST_STATUSES = new Set(['pass', 'fail', 'unknown']);
+const absent = (v) => v === undefined || v === null;
+function isHandoffEvidence(v) {
+    if (!(v instanceof Object) || Array.isArray(v))
+        return false;
+    const { gitRef, dirtyTree, testStatus, derivedFrom } = v;
+    return (absent(gitRef) || isJsonString(gitRef))
+        && (absent(dirtyTree) || dirtyTree === true || dirtyTree === false)
+        && (absent(testStatus) || TEST_STATUSES.has(testStatus))
+        && (derivedFrom === undefined || derivedFrom === 'transcript');
+}
+/** A stored list column as strings; a damaged one logs and reads as empty instead of hiding the whole handoff. */
+function storedList(row, column) {
+    const raw = row[column];
+    if (!raw)
+        return [];
+    try {
+        const parsed = JSON.parse(raw);
+        return Array.isArray(parsed) ? parsed.map((item) => String(item)) : [];
+    }
+    catch {
+        warnDamagedColumn({ table: 'session_handoffs', id: row.id, column }, 'not valid JSON');
+        return [];
+    }
+}
+/** Stored evidence, or null (after a log line) when the column is damaged or holds another shape. */
+function storedEvidence(row) {
+    if (!row.evidence_json)
+        return null;
+    const site = { table: 'session_handoffs', id: row.id, column: 'evidence_json' };
+    let parsed;
+    try {
+        parsed = JSON.parse(row.evidence_json);
+    }
+    catch {
+        warnDamagedColumn(site, 'not valid JSON');
+        return null;
+    }
+    if (parsed === null)
+        return null;
+    if (isHandoffEvidence(parsed))
+        return parsed;
+    warnDamagedColumn(site, 'wrong shape');
+    return null;
+}
+export function rowToSessionHandoff(row) {
+    const artifacts = storedList(row, 'artifacts_json');
+    const constraints = storedList(row, 'constraints_json');
+    const evidence = storedEvidence(row);
+    return {
+        version: 1,
+        sessionId: row.session_id,
+        repoRoot: row.repo_root ?? undefined,
+        taskId: row.task_id ?? undefined,
+        summary: row.summary,
+        nextAction: row.next_action ?? undefined,
+        artifacts,
+        scope: row.scope ?? null,
+        updatedAt: row.created_at,
+        constraints,
+        evidence,
+        outcome: isHandoffOutcome(row.outcome) ? row.outcome : null,
+        targetRuntime: row.target_runtime ?? null,
+        cardId: row.card_id ?? null,
+    };
+}
+//# sourceMappingURL=handoff.js.map

package/dist/{memory-quality.js → core/memory-quality.js}

@@ -1,5 +1,5 @@
 import { COMPACTION_MEMORY_TAG, COMPACTION_SOURCE_PREFIX } from './memory.js';
-import { heldTexts } from './same-text.js';
+import { heldTexts } from '../util/same-text.js';
 export const STOP_WORDS = new Set([
     'the', 'a', 'an', 'is', 'was', 'are', 'were', 'be', 'been', 'being',
     'to', 'of', 'in', 'for', 'on', 'with', 'at', 'by', 'from', 'it',
@@ -28,7 +28,7 @@ export function isReleaseCommitNoise(text) {
 /** Short preferences and rules carry a useful relationship even without a path or number. */
 export function hasNoSpecificity(text) {
     const domainAcronyms = (text.match(/\b[A-Z]{2,6}\b/g) ?? []).filter(a => !CHAT_ACRONYMS.test(a));
-    if (/\d|[A-Z][a-z]{2,}|[/\\.]|[`_{}()\[\]]/.test(text))
+    if (/\d|[A-Z][a-z]{2,}|[/\\.]|[`_{}()[\]]/.test(text))
         return false;
     if (domainAcronyms.length > 0 && /[a-z]/.test(text))
         return false;