hippo-memory 1.72.0 → 2.1.0

package/dist/core/handoff.d.ts

@@ -1,4 +1,7 @@
-/** 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. */
+/**
+ * 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. */
@@ -6,7 +9,9 @@ export interface HandoffEvidence {
     gitRef?: string | null;
     dirtyTree?: boolean | null;
     testStatus?: 'pass' | 'fail' | 'unknown' | null;
-    /** 'transcript' when hippo read the handoff off the session's transcript at session end; a later exit may replace it. */
+    /**
+     * 'transcript' when hippo read the handoff off the session's transcript at session end; a later exit may replace it.
+     */
     derivedFrom?: 'transcript';
 }
 /** Narrows an unvalidated value (e.g. CLI input or event content) to a HandoffOutcome. */

package/dist/core/handoff.js

@@ -1,4 +1,7 @@
-/** 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. */
+/**
+ * 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. */

package/dist/core/markdown.js

@@ -1,5 +1,5 @@
 import { DEFAULT_TENANT_ID } from '../util/env.js';
-import { FALLBACK_HALF_LIFE_DAYS, DEFAULT_SCHEMA_FIT } from './memory.js';
+import { FALLBACK_HALF_LIFE_DAYS, DEFAULT_SCHEMA_FIT, } from './memory.js';
 import { dumpFrontmatter, parseFrontmatter } from '../util/yaml.js';
 /** The fields every mirror file carries; serializeEntry adds the optional ones. */
 function entryFrontmatter(entry) {
@@ -42,7 +42,7 @@ export function serializeEntry(entry) {
     const frontmatter = entryFrontmatter(entry);
     // Emit tenant_id only when not 'default' to keep diffs clean for the dominant
     // single-tenant case (mirrors the plan's task 7 guidance).
-    const tenantId = entry.tenantId ?? DEFAULT_TENANT_ID;
+    const tenantId = entry.tenant_id ?? DEFAULT_TENANT_ID;
     if (tenantId !== DEFAULT_TENANT_ID) {
         frontmatter['tenant_id'] = tenantId;
     }
@@ -51,7 +51,8 @@ export function serializeEntry(entry) {
     if (entry.origin_project !== undefined) {
         frontmatter['origin_project'] = entry.origin_project;
     }
-    // Spread into a fresh literal: dumpFrontmatter's Record<string, YamlValue> needs an index signature, which the named interface does not structurally provide.
+    // Spread into a fresh literal: dumpFrontmatter's Record<string, YamlValue> needs an index signature, which the named
+    // interface does not structurally provide.
     const fm = dumpFrontmatter({ ...frontmatter });
     return `${fm}\n\n${entry.content}\n`;
 }
@@ -60,8 +61,8 @@ export function deserializeEntry(raw) {
     const { data, content } = parseFrontmatter(raw);
     if (!data['id'] || !data['layer'])
         return null;
-    // SAFETY: each `as X` narrows a raw YAML field to a MemoryEntry union member; frontmatter is only written by serializeEntry,
-    // so out-of-range values mean hand-edited files, which this parser may accept (permissive parse).
+    // SAFETY: each `as X` narrows a raw YAML field to a MemoryEntry union member; frontmatter is only written by
+    // serializeEntry, so out-of-range values mean hand-edited files, which this parser may accept (permissive parse).
     return {
         id: String(data['id']),
         created: String(data['created'] ?? new Date().toISOString()),
@@ -84,24 +85,28 @@ export function deserializeEntry(raw) {
         parents: normalizeStringArray(data['parents']),
         starred: Boolean(data['starred'] ?? false),
         trace_outcome: data['trace_outcome'] ?? null,
-        source_session_id: data['source_session_id'] === null || data['source_session_id'] === undefined
-            ? null
-            : String(data['source_session_id']),
+        source_session_id: nullableString(data['source_session_id']),
         valid_from: data['valid_from'] ? String(data['valid_from']) : String(data['created'] ?? new Date().toISOString()),
-        superseded_by: data['superseded_by'] === null || data['superseded_by'] === undefined
-            ? null
-            : String(data['superseded_by']),
+        superseded_by: nullableString(data['superseded_by']),
         extracted_from: data['extracted_from'] ?? null,
         dag_level: Number(data['dag_level'] ?? 0),
         dag_parent_id: data['dag_parent_id'] ?? null,
-        kind: (data['kind'] ?? 'distilled'),
-        scope: data['scope'] === null || data['scope'] === undefined ? null : String(data['scope']),
-        owner: data['owner'] === null || data['owner'] === undefined ? null : String(data['owner']),
-        artifact_ref: data['artifact_ref'] === null || data['artifact_ref'] === undefined ? null : String(data['artifact_ref']),
-        tenantId: data['tenant_id'] === null || data['tenant_id'] === undefined ? DEFAULT_TENANT_ID : String(data['tenant_id']),
-        origin_project: !('origin_project' in data) ? undefined : data['origin_project'] === null ? null : String(data['origin_project']),
+        kind: data['kind'] ?? 'distilled',
+        scope: nullableString(data['scope']),
+        owner: nullableString(data['owner']),
+        artifact_ref: nullableString(data['artifact_ref']),
+        tenant_id: nullableString(data['tenant_id']) ?? DEFAULT_TENANT_ID,
+        origin_project: originProjectOf(data),
     };
 }
+function originProjectOf(data) {
+    if (!('origin_project' in data))
+        return undefined;
+    return data['origin_project'] === null ? null : String(data['origin_project']);
+}
+function nullableString(value) {
+    return value === null || value === undefined ? null : String(value);
+}
 function normalizeStringArray(value) {
     if (!Array.isArray(value))
         return [];

package/dist/core/memory-audit.js

@@ -3,7 +3,8 @@ import { canAutoDelete } from './memory.js';
 import { automaticDefect, hasNoSpecificity, isFragment, isReleaseCommitNoise, substantiveWordCount, } from './memory-quality.js';
 export function auditMemory(entry, backsObject = false) {
     const issue = classifyMemory(entry);
-    // Error means "auto-remove"; a pinned, raw, kept-for-good or object-backing row is never auto-removed, so it can only warn.
+    // Error means "auto-remove"; a pinned, raw, kept-for-good or object-backing row is never auto-removed, so it can only
+    // warn.
     if (issue?.severity === 'error' && (!canAutoDelete(entry) || backsObject)) {
         const why = entry.pinned ? 'pinned' : entry.kind === 'raw' ? 'raw' : backsObject ? 'backs an object' : 'keep rule';
         return { ...issue, severity: 'warning', reason: `${issue.reason} (${why}, kept)` };
@@ -26,10 +27,20 @@ function classifyMemory(entry) {
     }
     const substantive = substantiveWordCount(content);
     if (substantive < 2) {
-        return { memoryId: entry.id, content, severity: 'warning', reason: `only ${substantive} substantive word(s) — too vague` };
+        return {
+            memoryId: entry.id,
+            content,
+            severity: 'warning',
+            reason: `only ${substantive} substantive word(s) — too vague`,
+        };
     }
     if (content.length < 40 && hasNoSpecificity(content)) {
-        return { memoryId: entry.id, content, severity: 'warning', reason: 'no specific details (names, paths, numbers, code)' };
+        return {
+            memoryId: entry.id,
+            content,
+            severity: 'warning',
+            reason: 'no specific details (names, paths, numbers, code)',
+        };
     }
     const reason = automaticDefect(entry);
     if (reason !== null) {

package/dist/core/memory-quality.d.ts

@@ -19,11 +19,20 @@ export declare function isCertainReason(reason: AutomaticMemoryDefect | null): b
 export declare function certainDefect(content: string): AutomaticMemoryDefect | null;
 export declare const BUNDLE_HEADER: RegExp;
 type Provenance = Pick<MemoryEntry, 'source' | 'confidence' | 'content' | 'extracted_from' | 'dag_level' | 'tags'>;
-/** A row hippo wrote that no person vouched for: hippo's writers stamp observed or inferred, a person's edit or restore verified. */
+/**
+ * A row hippo wrote that no person vouched for: hippo's writers
+ * stamp observed or inferred, a person's edit or restore verified.
+ */
 export declare function isAutomaticEntry(entry: Provenance): boolean;
-/** The audit's check: a person's row is never judged, and a bundle is flagged only when every part is, as reuse and recent context judge it. */
+/**
+ * The audit's check: a person's row is never judged, and a bundle is flagged only when every part is, as reuse and
+ * recent context judge it.
+ */
 export declare function automaticDefect(entry: Provenance): AutomaticMemoryDefect | null;
-/** Whether sleep may derive from a row or share it: a person's text and watch failures always, hippo's own text only without a certain defect. */
+/**
+ * Whether sleep may derive from a row or share it: a person's text and watch failures always, hippo's own text only
+ * without a certain defect.
+ */
 export declare function isReusable(entry: Provenance): boolean;
 /** The person floor's fragment test, on trimmed text. */
 export declare function isFragment(text: string): boolean;

package/dist/core/memory-quality.js

@@ -25,6 +25,9 @@ export function isReleaseCommitNoise(text) {
         || /^(?:Merge branch|Merge pull request)\b/i.test(text)
         || /^WIP\b/i.test(text);
 }
+const NOT_FILLER_WORD = String.raw `(?!(?:the|that|this|it|them|those|these|one|other|something)\b)\S+`;
+const PREFER_TARGET = new RegExp(String.raw `^(?:prefer|use|avoid|never use|don't use)\s+` + NOT_FILLER_WORD, 'i');
+const ALWAYS_NEVER_TARGET = new RegExp(String.raw `\b(?:never|always|must)\s+` + NOT_FILLER_WORD, 'i');
 /** 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));
@@ -32,14 +35,18 @@ export function hasNoSpecificity(text) {
         return false;
     if (domainAcronyms.length > 0 && /[a-z]/.test(text))
         return false;
-    if (/^(?:prefer|use|avoid|never use|don't use)\s+(?!(?:the|that|this|it|them|those|these|one|other|something)\b)\S+/i.test(text))
+    if (PREFER_TARGET.test(text))
         return false;
-    if (/\b(?:never|always|must)\s+(?!(?:the|that|this|it|them|those|these|one|other|something)\b)\S+/i.test(text))
+    if (ALWAYS_NEVER_TARGET.test(text))
         return false;
     return text.split(/\s+/).length < 8 && /^[\w\s,.'"-]+$/.test(text);
 }
 const RELATION_WORD = /\b(?:when|if|unless|because|since|after|before|until|while|so|instead)\b/i;
 const RULE_WORD = /\b(?:never|always|must|don't|do not|make sure|ensure|prefer|avoid)\b/i;
+const VERSION_BUMP = new RegExp(String.raw `^(?:bump|increment|increase|update|set)\s+(?:(?:ios|android|app)\s+)?` +
+    String.raw `(?:build(?:\s+number)?|version|release)\s+(?:to\s+)?(?:v?\d|#\d)`, 'i');
+const DEPLOY_ACTION = new RegExp(String.raw `^(?:deploy(?:ed|ing)?|ship(?:ped|ping)?|release(?:d|ing)?)\s+(?:the\s+)?` +
+    String.raw `(?:build|release|version|v?\d)\s*(?:v?\d|#\d|\.\d)`, 'i');
 function isRoutineReleaseActivity(text) {
     if (isReleaseCommitNoise(text))
         return true;
@@ -47,14 +54,15 @@ function isRoutineReleaseActivity(text) {
     if (RELATION_WORD.test(text) || RULE_WORD.test(text))
         return false;
     const subject = text.replace(/^(?:chore|ci|build)(?:\([^)]*\))?:\s*/i, '');
-    if (/^(?:bump|increment|increase|update|set)\s+(?:(?:ios|android|app)\s+)?(?:build(?:\s+number)?|version|release)\s+(?:to\s+)?(?:v?\d|#\d)/i.test(subject))
+    if (VERSION_BUMP.test(subject))
         return true;
-    return /^(?:deploy(?:ed|ing)?|ship(?:ped|ping)?|release(?:d|ing)?)\s+(?:the\s+)?(?:build|release|version|v?\d)\s*(?:v?\d|#\d|\.\d)/i.test(subject)
-        || /^(?:deployment|release|build)\s+(?:succeeded|completed|finished)\b/i.test(subject);
+    return (DEPLOY_ACTION.test(subject) ||
+        /^(?:deployment|release|build)\s+(?:succeeded|completed|finished)\b/i.test(subject));
 }
 const bareText = (text) => text.replace(/[.!?,;:\s]+$/, '');
 // These endings close whole sentences too ("the branch you push to"), so they are only a possible cut.
-const POSSIBLE_CUT_ENDING = /\b(?:needs to|depends on|requires|while|with|without|into|for|of|by|to|is|are|was|were|must|should|could|would|might)$/i;
+const POSSIBLE_CUT_ENDING = new RegExp(String.raw `\b(?:needs to|depends on|requires|while|with|without|into|for|of|by|to|is|are|was|were|` +
+    String.raw `must|should|could|would|might)$`, 'i');
 /** A short leading condition with no rule word, comma or "then": "If the build fails". */
 function isBareCondition(bare) {
     return !/[,;]|\bthen\b/i.test(bare) && !RULE_WORD.test(bare) && bare.split(/\s+/).length <= 6;
@@ -64,9 +72,12 @@ function isDanglingAssertion(text) {
     // Only a lowercase start is a cut: "To rebuild the index, run ..." opens an instruction.
     if (/^(?:to|and|for)\s/.test(bare) && bare.length < 50)
         return true;
-    // Prepositions, modals and "is" can end a whole sentence ("the branch it merges into"), so only cut-off endings count.
-    if (/\b(?:to be|has been|will be|instead of|rather than|such as|than|because|if|unless|when|until|and|or|but)$/i.test(bare) || /\b(?:the|a|an)$/.test(bare))
+    // Prepositions, modals and "is" can end a whole sentence ("the
+    // branch it merges into"), so only cut-off endings count.
+    if (/\b(?:to be|has been|will be|instead of|rather than|such as|than|because|if|unless|when|until|and|or|but)$/i.test(bare) ||
+        /\b(?:the|a|an)$/.test(bare)) {
         return true;
+    }
     return /^(?:if|unless|when|while|until)\b/.test(bare) && isBareCondition(bare);
 }
 /** A capitalised short condition may carry its rule with no comma: "When CI fails we retry once". */
@@ -74,19 +85,25 @@ function isPossibleFragment(text) {
     const bare = bareText(text);
     return POSSIBLE_CUT_ENDING.test(bare) || (/^(?:If|Unless|When|While|Until)\b/.test(bare) && isBareCondition(bare));
 }
-const OUTCOME_LEAD = /^(?:succeeds?|succeeded|fails?|failed|passes|passed|completed|done|successful|success|returned|returns|inserted|updated|deleted)\b/i;
-const OUTCOME_DETAIL = /\b(?:for|on|in|at|to|from|with|without|by|after|before|under|is|are|was|were|be|been|will|can|must|should|never|always)\b/i;
+const OUTCOME_LEAD = new RegExp(String.raw `^(?:succeeds?|succeeded|fails?|failed|passes|passed|completed|done|successful|success|` +
+    String.raw `returned|returns|inserted|updated|deleted)\b`, 'i');
+const OUTCOME_DETAIL = new RegExp(String.raw `\b(?:for|on|in|at|to|from|with|without|by|after|before|under|is|are|was|were|be|been|` +
+    String.raw `will|can|must|should|never|always)\b`, 'i');
 function isSubjectlessOutcome(text) {
     const lead = OUTCOME_LEAD.exec(text);
     if (lead === null || RELATION_WORD.test(text))
         return false;
-    // "Returns 404 for unknown ids" and "Deleted rows must stay deleted" say when or what; "returned 3 matching rows" does not.
+    // "Returns 404 for unknown ids" and "Deleted rows must stay
+    // deleted" say when or what; "returned 3 matching rows" does not.
     return !OUTCOME_DETAIL.test(text.slice(lead[0].length).replace(/\([^)]*\)/g, ' '));
 }
-const OUTPUT_LINE = /^(?:\$\s|>\s|(?:stdout|stderr|exit code):|Command\s+['"].*\s+failed\b|Traceback\b|npm\s+(?:ERR|WARN)\b|error\s+TS\d+\b)/i;
+// `(?:.*\S)?` ends the quoted command on a non-space, so it and `\s+` never share a run of spaces (no ReDoS).
+const OUTPUT_LINE = new RegExp(String.raw `^(?:\$\s|>\s|(?:stdout|stderr|exit code):|Command\s+['"](?:.*\S)?\s+failed\b|` +
+    String.raw `Traceback\b|npm\s+(?:ERR|WARN)\b|error\s+TS\d+\b)`, 'i');
 const STACK_FRAME = /^at\s+\S.*:\d+(?::\d+)?\)?$/;
 const ERROR_LEAD = /^(?:[\w.$]+Error|[\w.$]+Exception):\s/;
-// Log lines say "after" and "while" too, so only a rule word frees a timestamp or level lead: a dated freeze saying never merge.
+// Log lines say "after" and "while" too, so only a rule word frees
+// a timestamp or level lead: a dated freeze saying never merge.
 const LOG_LEADS = [
     /^\d{4}-\d{2}-\d{2}[T ][\d:.]+(?:Z|[+-][\d:]+)?\s+(?:\[?\w+\]?\s+)?/,
     /^\[(?:info|warn|error|debug)\]/i,
@@ -129,7 +146,12 @@ export function assessAutomaticMemory(content) {
     return { accepted: reason === null || reason === 'possible-fragment', reason };
 }
 /** Reasons the heuristics can get wrong: repair only lists them for review and derivation still admits them. */
-const UNCERTAIN_REASONS = new Set(['too-short', 'possible-fragment', 'too-vague', 'no-specificity']);
+const UNCERTAIN_REASONS = new Set([
+    'too-short',
+    'possible-fragment',
+    'too-vague',
+    'no-specificity',
+]);
 export function isCertainReason(reason) {
     return reason !== null && !UNCERTAIN_REASONS.has(reason);
 }
@@ -138,13 +160,18 @@ export function certainDefect(content) {
     const { reason } = assessAutomaticMemory(content);
     return isCertainReason(reason) ? reason : null;
 }
-// Watch failures ('autolearn') and tool failures keep a fixed "Command 'x' failed" format by design, so they are not judged.
+// Watch failures ('autolearn') and tool failures keep a fixed
+// "Command 'x' failed" format by design, so they are not judged.
 const AUTOMATIC_SOURCES = new Set(['capture', 'git-learn', 'git', 'consolidation']);
-// Promote and share rewrite the source but keep the tags, so the writer's tag still marks a copy; elsewhere a person may set it.
+// Promote and share rewrite the source but keep the tags, so the writer's tag still marks a copy; elsewhere a person
+// may set it.
 const AUTOMATIC_TAGS = new Set(['captured', COMPACTION_MEMORY_TAG, 'git-learned']);
 const COPY_SOURCE = /^(?:promoted|shared):/;
 export const BUNDLE_HEADER = /^\[Consolidated(?: from| pattern from) \d+ related memor(?:y|ies)(?:, newest first)?\]\n\n/;
-/** A row hippo wrote that no person vouched for: hippo's writers stamp observed or inferred, a person's edit or restore verified. */
+/**
+ * A row hippo wrote that no person vouched for: hippo's writers
+ * stamp observed or inferred, a person's edit or restore verified.
+ */
 export function isAutomaticEntry(entry) {
     if (entry.confidence !== 'observed' && entry.confidence !== 'inferred')
         return false;
@@ -152,7 +179,9 @@ export function isAutomaticEntry(entry) {
         || (COPY_SOURCE.test(entry.source) && entry.tags.some((tag) => AUTOMATIC_TAGS.has(tag)))
         || entry.extracted_from !== null || entry.dag_level >= 1 || BUNDLE_HEADER.test(entry.content);
 }
-/** A bundle's parts are other rows' words, possibly a person's, so a bundle is sure to be junk only when every part is. */
+/**
+ * A bundle's parts are other rows' words, possibly a person's, so a bundle is sure to be junk only when every part is.
+ */
 function bundleParts(entry) {
     return BUNDLE_HEADER.test(entry.content) ? heldTexts({ content: entry.content, source: 'consolidation' }) : [];
 }
@@ -160,7 +189,10 @@ function hasCertainDefect(entry) {
     const parts = bundleParts(entry);
     return (parts.length > 0 ? parts : [entry.content]).every((text) => certainDefect(text) !== null);
 }
-/** The audit's check: a person's row is never judged, and a bundle is flagged only when every part is, as reuse and recent context judge it. */
+/**
+ * The audit's check: a person's row is never judged, and a bundle is flagged only when every part is, as reuse and
+ * recent context judge it.
+ */
 export function automaticDefect(entry) {
     if (!isAutomaticEntry(entry))
         return null;
@@ -168,7 +200,10 @@ export function automaticDefect(entry) {
     const reasons = (parts.length > 0 ? parts : [entry.content.trim()]).map((text) => assessAutomaticMemory(text).reason);
     return reasons.every((reason) => reason !== null) ? reasons[0] ?? null : null;
 }
-/** Whether sleep may derive from a row or share it: a person's text and watch failures always, hippo's own text only without a certain defect. */
+/**
+ * Whether sleep may derive from a row or share it: a person's text and watch failures always, hippo's own text only
+ * without a certain defect.
+ */
 export function isReusable(entry) {
     return !isAutomaticEntry(entry) || !hasCertainDefect(entry);
 }
@@ -182,8 +217,9 @@ export function isContentWorthStoring(content) {
 }
 /** Recent-context floor: rows hippo wrote meet the automatic check, a person's rows only the older, looser floor. */
 export function isWorthSurfacing(entry) {
-    if (isAutomaticEntry(entry))
+    if (isAutomaticEntry(entry)) {
         return bundleParts(entry).length > 0 ? !hasCertainDefect(entry) : isContentWorthStoring(entry.content);
+    }
     const text = entry.content.trim();
     return text.length >= 10 && !isReleaseCommitNoise(text) && !isFragment(text)
         && substantiveWordCount(text) >= 2 && !(text.length < 40 && hasNoSpecificity(text));

package/dist/core/memory.d.ts

@@ -44,8 +44,11 @@ export interface MemoryEntry {
     descendant_count?: number;
     earliest_at?: string | null;
     latest_at?: string | null;
-    /** 1 when a child was invalidated, superseded, forgotten or archived since the last rebuild; sleep clears it. Always 0 below level 2. */
-    summary_dirty?: 0 | 1;
+    /**
+     * True when a child was invalidated, superseded, forgotten or archived since the last rebuild; sleep clears it.
+     * Always false below level 2.
+     */
+    summary_dirty?: boolean;
     /** ISO 8601 time of the last successful rebuild, or null if never rebuilt. */
     last_rebuilt_at?: string | null;
     /** Count of successful rebuilds: 0 at the first buildDag write, bumped by each rebuild. */
@@ -56,14 +59,24 @@ export interface MemoryEntry {
     scope: string | null;
     owner: string | null;
     artifact_ref: string | null;
-    tenantId: string;
-    /** Owning project, lowercased; '' = user-global (injectable everywhere), null = none known (legacy or unnamed write), denied by ambient context.
+    tenant_id: string;
+    /**
+     * Owning project, lowercased; '' = user-global (injectable everywhere), null = none known (legacy or unnamed write),
+     * denied by ambient context.
      *  Stamped at write time by stampOriginProject (src/store/entry-row.ts); undefined only before the first write. */
     origin_project?: string | null;
-    /** Raw FTS5 bm25() from the search path (negative, lower = better); set only for a non-empty query the FTS join answered.
+    /**
+     * Raw FTS5 bm25() from the search path (negative, lower = better); set only for a non-empty query the FTS join
+     * answered.
      *  Not comparable to the JS scorer in src/search/bm25.ts, so read it as rank metadata only. */
     bm25_score?: number;
 }
+/** Named dag_level values; level 0 is a raw leaf. */
+export declare const DAG_LEVEL: {
+    readonly extracted: 1;
+    readonly topic: 2;
+    readonly entity: 3;
+};
 /** Tag on a memory whose named file/symbol/script changed after it was stored. */
 export declare const CHURN_STALE_TAG = "churn-stale";
 export declare const EMOTIONAL_MULTIPLIERS: {
@@ -72,22 +85,36 @@ export declare const EMOTIONAL_MULTIPLIERS: {
     negative: number;
     critical: number;
 };
-/** Test-only: a test that sets HIPPO_LOSS_AVERSION_RATIO calls this in beforeEach and afterEach (tests/emotional-multipliers.test.ts). */
+/**
+ * Test-only: a test that sets HIPPO_LOSS_AVERSION_RATIO calls this in beforeEach and afterEach
+ * (tests/emotional-multipliers.test.ts).
+ */
 export declare function _resetLossAversionRatioCacheForTests(): void;
-/** Scales only the `negative` multiplier; `critical` stays unscaled so the knob moves just the losses-vs-gains claim. */
+/**
+ * Scales only the `negative` multiplier; `critical` stays unscaled so the knob moves just the losses-vs-gains claim.
+ */
 export declare function applyLossAversionRatio(valence: EmotionalValence, baseMultiplier: number): number;
-/** 1 + REWARD_SLOPE * (pos - neg) / (pos + neg + 1), in (0.5, 1.5), 1.0 with no outcomes; it scales the effective half-life. */
+/**
+ * 1 + REWARD_SLOPE * (pos - neg) / (pos + neg + 1), in (0.5, 1.5), 1.0 with no outcomes; it scales the effective
+ * half-life.
+ */
 export declare function calculateRewardFactor(entry: Pick<MemoryEntry, 'outcome_positive' | 'outcome_negative'>, ablation?: StrengthAblation): number;
 /** Bad marks alone never push a memory under sleep's 0.05 retire line; supersede is the hard correction. */
 export declare const MAX_WRONG_HALVINGS = 3;
 export declare const DECAY_BASE = 0.5;
 export declare const REWARD_SLOPE = 0.5;
 export declare const RETRIEVAL_BOOST_SLOPE = 0.1;
-/** Bad outcome marks past good ones, floored at zero; each halves strength and stops recall strengthening, so a correction outranks pinning. */
+/**
+ * Bad outcome marks past good ones, floored at zero; each halves strength and stops recall strengthening, so a
+ * correction outranks pinning.
+ */
 export declare function netWrong(entry: Pick<MemoryEntry, 'outcome_positive' | 'outcome_negative'>, ablation?: StrengthAblation): number;
 /** What calculateStrength reads, so a caller can score a row without loading its text. */
 export type StrengthInputs = Pick<MemoryEntry, 'pinned' | 'created' | 'last_retrieved' | 'half_life_days' | 'retrieval_count' | 'emotional_valence' | 'outcome_positive' | 'outcome_negative'>;
-/** Decay basis: clock = wall time, session = per sleep cycle (intermittent agents), adaptive = half-life scaled by session frequency. */
+/**
+ * Decay basis: clock = wall time, session = per sleep cycle (intermittent agents), adaptive = half-life scaled by
+ * session frequency.
+ */
 export interface DecayOptions {
     decayBasis?: 'clock' | 'session' | 'adaptive';
     /** Average interval between sleep cycles, in days. Used by 'adaptive' and 'session' modes. */
@@ -97,12 +124,19 @@ export interface DecayOptions {
     /** EVAL-ONLY switches resolved once at the entry layer (`strengthAblation()`); absent means production scoring. */
     ablation?: StrengthAblation;
 }
-/** Strength at `now` = decay * retrieval boost * emotional multiplier, clamped to [0, 1]; the basis modes are on DecayOptions.
+/**
+ * Strength at `now` = decay * retrieval boost * emotional multiplier, clamped to [0, 1]; the basis modes are on
+ * DecayOptions.
  *  Pinned memories skip time decay, but being marked wrong still fades them (netWrong). */
 export declare function calculateStrength(entry: StrengthInputs, now?: Date, options?: DecayOptions): number;
+/** A memory counts as high schema fit strictly above this. */
+export declare const HIGH_SCHEMA_FIT = 0.7;
 /** The base half-life scaled by the PLAN.md signals: an error tag, and high or low schema fit. */
 export declare function deriveHalfLife(base: number, entry: Partial<MemoryEntry>): number;
-/** Counts the outcome; calculateStrength turns the counts into a reward factor on the half-life, so there is no fixed delta here. */
+/**
+ * Counts the outcome; calculateStrength turns the counts into a reward factor on the half-life, so there is no fixed
+ * delta here.
+ */
 export declare function applyOutcome(entry: MemoryEntry, good: boolean): MemoryEntry;
 /** applyOutcome as a served outcome applies it: a good outcome reconfirms the entry, so its churn-stale tag goes. */
 export declare function entryAfterOutcome(entry: MemoryEntry, good: boolean): MemoryEntry;
@@ -114,20 +148,30 @@ export interface ConfidenceFacets {
     tier: ConfidenceLevel;
     agedOut: boolean;
 }
-export declare function confidenceFacets(entry: MemoryEntry, now?: Date): ConfidenceFacets;
+export declare function confidenceFacets(entry: ConfidenceInputs, now?: Date): ConfidenceFacets;
 export declare function facetsOf(entry: ConfidenceInputs, now: Date): ConfidenceFacets;
 export declare function confidenceLabel(entry: MemoryEntry, now?: Date): {
     text: string;
     warn: boolean;
 };
-/** The stored confidence, or 'stale' once the entry is aged out (not retrieved for AGED_OUT_AFTER_DAYS; pinned and verified exempt). */
+/**
+ * The stored confidence, or 'stale' once the entry is aged out (not retrieved for AGED_OUT_AFTER_DAYS; pinned and
+ * verified exempt).
+ */
 export declare function resolveConfidence(entry: MemoryEntry, now?: Date): ConfidenceLevel;
-/** Base half-life in days before deriveHalfLife's multipliers: 365 because 7 lost the current fact far more often and 730 did no better.
+/**
+ * Base half-life in days before deriveHalfLife's multipliers: 365 because 7 lost the current fact far more often and
+ * 730 did no better.
  *  `hippo sleep` moves memories still on an older base (src/consolidate/half-life-migration.ts). */
 export declare const DEFAULT_HALF_LIFE_DAYS = 365;
+/** The flat half-life the decision, incident and other object writers gave their memories before they took the
+ * default. */
+export declare const LEGACY_TYPED_HALF_LIFE = 90;
 export declare const COMPACTION_MEMORY_TAG = "compaction-memory";
 export declare const COMPACTION_SOURCE_PREFIX = "compaction:";
-/** An imported agent memory is kept for good: the agent's note file is its record. It needs both its tool's tag and a source with that tool's prefix,
+/**
+ * An imported agent memory is kept for good: the agent's note file is its record. It needs both its tool's tag and a
+ * source with that tool's prefix,
  *  since merge copies source tags onto rows whose source is 'consolidation'. */
 export interface KeepPair {
     readonly tag: string;
@@ -136,31 +180,40 @@ export interface KeepPair {
 export declare const KEEP_PAIRS: readonly KeepPair[];
 export declare function isKeptForGood(entry: Pick<MemoryEntry, 'tags' | 'source' | 'superseded_by'>): boolean;
 export declare function canAutoDelete(entry: Pick<MemoryEntry, 'pinned' | 'kind' | 'tags' | 'source' | 'superseded_by'>): boolean;
+/** Options are camelCase; `MemoryEntry` keeps the snake_case stored-row names. */
 export interface CreateMemoryOptions {
     layer?: Layer;
     tags?: string[];
-    emotional_valence?: EmotionalValence;
+    emotionalValence?: EmotionalValence;
     pinned?: boolean;
-    schema_fit?: number;
+    schemaFit?: number;
     source?: string;
     confidence?: ConfidenceLevel;
-    /** The store's `loadConfig(hippoRoot).defaultHalfLifeDays`; required so no writer silently gets the compiled default. */
+    /**
+     * The store's `loadConfig(hippoRoot).defaultHalfLifeDays`; required so no writer silently gets the compiled default.
+     */
     baseHalfLifeDays: number;
-    trace_outcome?: TraceOutcome;
-    source_session_id?: string | null;
-    valid_from?: string;
-    extracted_from?: string;
-    dag_level?: number;
-    dag_parent_id?: string;
+    traceOutcome?: TraceOutcome;
+    sourceSessionId?: string | null;
+    validFrom?: string;
+    extractedFrom?: string;
+    dagLevel?: number;
+    dagParentId?: string;
     kind?: MemoryKind;
     scope?: string | null;
     owner?: string | null;
-    artifact_ref?: string | null;
+    artifactRef?: string | null;
     tenantId?: string;
 }
-/** Create a new memory entry with defaults. Untyped JavaScript callers that omit the options get the compiled default half-life. */
+/**
+ * Create a new memory entry with defaults. Untyped JavaScript callers that omit the options get the compiled default
+ * half-life.
+ */
 export declare function createMemory(content: string, options: CreateMemoryOptions): MemoryEntry;
-/** The row that replaces `old`: a supersede never changes where a memory belongs, so source, scope, session and a stamped origin carry over. */
+/**
+ * The row that replaces `old`: a supersede never changes where a memory belongs, so source, scope, session and a
+ * stamped origin carry over.
+ */
 export declare function createSuccessor(old: MemoryEntry, content: string, opts: {
     tenantId: string;
     baseHalfLifeDays: number;
@@ -168,7 +221,9 @@ export declare function createSuccessor(old: MemoryEntry, content: string, opts:
     tags?: string[];
     pinned?: boolean;
 }): MemoryEntry;
-/** How well new content fits existing knowledge, 0..1: above 0.7 consolidates faster, below 0.3 is novel and decays faster if unused.
+/**
+ * How well new content fits existing knowledge, 0..1: above 0.7 consolidates faster, below 0.3 is novel and decays
+ * faster if unused.
  *  Tags shared with existing memories count by rarity (a rare shared tag fits more), plus content-token overlap. */
 export declare function computeSchemaFit(content: string, tags: string[], existingEntries: MemoryEntry[]): number;
 /** What schema fit reads from `entries`, built once for a caller that scores many contents against the same rows. */
@@ -184,6 +239,8 @@ export interface SchemaFitSource {
 /** computeSchemaFit against `source`, for a caller that holds counts and texts but no rows. */
 export declare function schemaFitFrom(content: string, tags: readonly string[], source: SchemaFitSource): number;
 /** Returns copies with the retrieval count, clock and half-life updated; the caller persists them.
- *  Under HIPPO_ABLATE_RECALL_BOOST (eval-only) the entries come back unchanged, not empty, since callers derive last_retrieval_ids from them. */
+ * Under HIPPO_ABLATE_RECALL_BOOST (eval-only) the entries come back unchanged, not empty, since callers derive
+ * last_retrieval_ids from them.
+ */
 export declare function markRetrieved(entries: MemoryEntry[], now?: Date, options?: Pick<DecayOptions, 'ablation'>): MemoryEntry[];
 //# sourceMappingURL=memory.d.ts.map