hippo-memory 2.0.0 → 2.1.0

package/dist/core/config.js

@@ -5,8 +5,8 @@ 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 { errorCode, errorMessage, log } from '../util/log.js';
+import { DEFAULT_LOCAL_BUMP, DEFAULT_MMR_LAMBDA, DEFAULT_RECALL_BUDGET } from './search-types.js';
+import { errorCode, errorMessage, log, errorFields } from '../util/log.js';
 import { isJsonObject } from '../util/json.js';
 export const DEFAULT_CONFIG = {
     defaultHalfLifeDays: DEFAULT_HALF_LIFE_DAYS,
@@ -35,7 +35,7 @@ export const DEFAULT_CONFIG = {
     physics: { ...DEFAULT_PHYSICS_CONFIG },
     mmr: {
         enabled: true,
-        lambda: 0.7,
+        lambda: DEFAULT_MMR_LAMBDA,
     },
     search: {
         localBump: DEFAULT_LOCAL_BUMP,
@@ -158,7 +158,8 @@ function memoryValueOverride(raw) {
     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 && !isJsonObject(dormantRaw)) {
@@ -200,7 +201,8 @@ function churnStalenessEnabled(raw) {
     return enabled;
 }
 function defaultHalfLifeDays(raw) {
-    // Every writer starts a memory on this, and a zero or negative half-life scores zero strength, so sleep would retire it.
+    // Every writer starts a memory on this, and a zero or negative half-life scores zero strength, so sleep would retire
+    // it.
     const days = raw.defaultHalfLifeDays ?? DEFAULT_CONFIG.defaultHalfLifeDays;
     if (!Number.isFinite(days) || days <= 0) {
         log.warn(`config.json's "defaultHalfLifeDays" must be a number of days above 0 ` +
@@ -218,7 +220,8 @@ function sharedStoreFlag(raw) {
     return false;
 }
 export function loadConfig(hippoRoot) {
-    // A caller that names no folder, as an add-on serving another store does, gets the defaults, never the working folder's config.json.
+    // 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');
@@ -236,7 +239,8 @@ export function loadConfig(hippoRoot) {
 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. */
+/** 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 });
@@ -245,14 +249,17 @@ function fileStamp(file) {
     catch (err) {
         const code = errorCode(err);
         const message = `config: ${file} could not be reached, read as missing: ${errorMessage(err)}`;
-        if (code === 'EACCES' || code === 'EPERM')
-            log.warnThenDebug(`config-unreachable:${file}:${code}`, message, { path: file, code });
+        if (code === 'EACCES' || code === 'EPERM') {
+            log.warnThenDebug(`config-unreachable:${file}:${code}`, message, { path: file, code, ...errorFields(err) });
+        }
+        // Any other refusal (ENOTDIR, ELOOP) means the path is simply not there, so only a permission refusal is told.
         else
-            log.debug(message);
+            log.debug(message, errorFields(err));
         return null;
     }
 }
-/** A config.json that exists must load: running on defaults would silently drop the user's settings, such as `sharedStore`. */
+/** A config.json that exists must load: running on defaults would silently drop the user's settings, such as
+ * `sharedStore`. */
 function readConfigFile(configPath) {
     let raw;
     try {
@@ -318,20 +325,23 @@ function configOverDefaults(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. */
+/** The folder as isGlobalStoreRoot compares it (realpath, case-folded on Windows); its helper sits behind an import
+ * cycle. */
 function sharedStoreKey(hippoRoot) {
     let real;
     try {
         real = fs.realpathSync.native(hippoRoot);
     }
     catch (err) {
-        log.debug(`sharedStore: realpath fell back to resolve for ${hippoRoot}: ${errorMessage(err)}`);
+        // A folder that does not exist yet has no real path, so the resolved one stands in.
+        log.debug(`sharedStore: realpath fell back to resolve for ${hippoRoot}: ${errorMessage(err)}`, errorFields(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, so loadConfig's warnings stay loadConfig's. */
+ * 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))

package/dist/core/cosine.d.ts

@@ -1,3 +1,6 @@
-/** Cosine over any indexable vectors (a Float32 view scores as its number[] copy); 0 for empty, mismatched or zero-norm input. */
+/**
+ * Cosine over any indexable vectors (a Float32 view scores as its number[] copy); 0 for empty, mismatched or zero-norm
+ * input.
+ */
 export declare function cosineOf(a: ArrayLike<number>, b: ArrayLike<number>): number;
 //# sourceMappingURL=cosine.d.ts.map

package/dist/core/cosine.js

@@ -1,4 +1,7 @@
-/** Cosine over any indexable vectors (a Float32 view scores as its number[] copy); 0 for empty, mismatched or zero-norm input. */
+/**
+ * Cosine over any indexable vectors (a Float32 view scores as its number[] copy); 0 for empty, mismatched or zero-norm
+ * input.
+ */
 export function cosineOf(a, b) {
     if (a.length === 0 || b.length === 0 || a.length !== b.length)
         return 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) {
@@ -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']),
-        tenant_id: 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));