hippo-memory 2.0.0 → 2.1.0

package/dist/learn/autolearn.d.ts

@@ -1,19 +1,22 @@
 /** Auto-learn from errors and git history.
  *  Agents learn from failures without explicit hippo remember calls. */
 import { MemoryEntry } from '../core/memory.js';
-/** A memory of a failed command, "Command '<cmd>' failed: <truncated stderr>"; `hippo watch` stores its text and tags through remember. */
+/** A memory of a failed command, "Command '<cmd>' failed: <truncated stderr>"; `hippo watch` stores its text and
+ * tags through remember. */
 export declare function captureError(exitCode: number, stderr: string, command: string, tenantId?: string): MemoryEntry;
 /** Parse git log output for actionable lessons.
  *  Looks for fix:, revert:, bug:, error:, hotfix: commit messages. */
 export declare function extractLessons(gitLog: string, customPatterns?: string[]): string[];
-/** Split parsed lessons into ones worth storing and low-information ones; kept out of `extractLessons` so that published parser's output cannot change.
+/** Split parsed lessons into ones worth storing and low-information ones; kept out of `extractLessons` so that
+ * published parser's output cannot change.
  *  Order is preserved in both arrays, and both hold lessons with secret shapes redacted. */
 export declare function partitionLessons(lessons: string[]): {
     kept: string[];
     dropped: string[];
 };
 /** Check if a substantially similar memory already exists: true if overlap > threshold (default 0.7).
- *  `tenantId` applies only on the root-string overload; a pre-loaded MemoryEntry[] is already scoped, so it is ignored there. */
+ * `tenantId` applies only on the root-string overload; a pre-loaded MemoryEntry[] is already scoped, so it is
+ * ignored there. */
 export declare function deduplicateLesson(hippoRootOrEntries: string | MemoryEntry[], lesson: string, threshold?: number, tenantId?: string): boolean;
 /** A transfer command that has not exited in this long is hung on a prompt or a dead remote. */
 export declare const RUN_WATCHED_DEADLINE_MS: number;
@@ -24,15 +27,23 @@ export declare class RunWatchedTimeoutError extends Error {
     constructor(deadlineMs: number, stderr: string);
 }
 export interface RunWatchedOptions {
-    /** Join argv with spaces and run it as one shell command line; only for text the caller wrote itself. */
+    /** Join argv with spaces and run it as one shell command line; kept for 2.x callers, new code uses runWatchedLine. */
     shell?: boolean;
 }
-/** Run argv[0] with the rest as its arguments and no shell, so `;`, `&` and `$()` reach it literally; stderr streams live.
- *  Returns: { exitCode, stderr } with only the last 64 KiB of stderr; rejects with RunWatchedTimeoutError past `deadlineMs`. */
+/** Run argv[0] with the rest as its arguments and no shell, so `;`, `&` and `$()` reach it literally; stderr streams
+ * live.
+ * Returns: { exitCode, stderr } with only the last 64 KiB of stderr; rejects with RunWatchedTimeoutError past
+ * `deadlineMs`. */
 export declare function runWatched(argv: readonly string[], deadlineMs?: number, opts?: RunWatchedOptions): Promise<{
     exitCode: number;
     stderr: string;
 }>;
+/** Run `line` as one shell command line, for text the caller wrote itself (`hippo watch --shell`); same result and
+ * deadline as runWatched. */
+export declare function runWatchedLine(line: string, deadlineMs?: number): Promise<{
+    exitCode: number;
+    stderr: string;
+}>;
 /** Check whether a directory is a git work tree. */
 export declare function isGitRepo(cwd: string): boolean;
 /** Fetch recent git log lines (subject lines only).

package/dist/learn/autolearn.js

@@ -3,18 +3,20 @@
 import { execFileSync, spawn } from 'child_process';
 import { spawnArgv } from '../util/spawn-argv.js';
 import { createMemory, Layer, DEFAULT_HALF_LIFE_DAYS } from '../core/memory.js';
-import { loadAllEntries } from '../store/entry-reads.js';
-import { textOverlap } from '../util/tokenize.js';
+import { localFilesAt } from './roots.js';
+import { textOverlap, tokenize } from '../util/tokenize.js';
 import { assessAutomaticMemory } from '../core/memory-quality.js';
 import { redactSecretsStrict } from '../util/secret-detect.js';
-import { errorMessage, log } from '../util/log.js';
+import { errorMessage, log, errorFields } from '../util/log.js';
 const AUTOLEARN_TEXT_CHARS = 500;
 const AUTOLEARN_TAG_CHARS = 30;
-/** A memory of a failed command, "Command '<cmd>' failed: <truncated stderr>"; `hippo watch` stores its text and tags through remember. */
+const MAX_LESSON_CHARS = 500;
+/** A memory of a failed command, "Command '<cmd>' failed: <truncated stderr>"; `hippo watch` stores its text and
+ * tags through remember. */
 export function captureError(exitCode, stderr, command, tenantId) {
     // Truncate to first 500 chars to avoid storing megabytes of build logs
     const clean = redactSecretsStrict(stderr);
-    const wasTruncated = clean.length > 500;
+    const wasTruncated = clean.length > AUTOLEARN_TEXT_CHARS;
     const truncated = clean.slice(0, AUTOLEARN_TEXT_CHARS).trim();
     const suffix = wasTruncated ? ' [truncated]' : '';
     // Strip leading env var assignments (KEY=val or key=val) before the actual command name
@@ -60,7 +62,7 @@ export function extractLessons(gitLog, customPatterns) {
             if (m) {
                 // For conventional commits: use group 3 (message after prefix), group 2, or full match
                 const lesson = (m[3] ?? m[2] ?? m[0]).trim();
-                if (lesson.length > 5 && lesson.length < 500) {
+                if (lesson.length > 5 && lesson.length < MAX_LESSON_CHARS) {
                     lessons.push(lesson);
                 }
                 break;
@@ -70,7 +72,8 @@ export function extractLessons(gitLog, customPatterns) {
     // Deduplicate exact matches at extraction time
     return [...new Set(lessons)];
 }
-/** Split parsed lessons into ones worth storing and low-information ones; kept out of `extractLessons` so that published parser's output cannot change.
+/** Split parsed lessons into ones worth storing and low-information ones; kept out of `extractLessons` so that
+ * published parser's output cannot change.
  *  Order is preserved in both arrays, and both hold lessons with secret shapes redacted. */
 export function partitionLessons(lessons) {
     const kept = [];
@@ -85,18 +88,31 @@ export function partitionLessons(lessons) {
     }
     return { kept, dropped };
 }
+// Never matches a real tag; the exact textOverlap re-check drops any row the content filter let through.
+const NO_TAG = '~no-such-tag~';
+/** Rows that can pass the overlap test: those sharing a token with the lesson. Falls back to every row when every row
+ * can match (no tokens, or a threshold below zero). */
+function candidateEntries(learning, lesson, threshold, tenantId) {
+    const tokens = tokenize(lesson);
+    if (tokens.length === 0 || threshold < 0) {
+        return learning.allEntries(tenantId);
+    }
+    return learning.entriesMentioning(tokens, NO_TAG, tenantId);
+}
 /** Check if a substantially similar memory already exists: true if overlap > threshold (default 0.7).
- *  `tenantId` applies only on the root-string overload; a pre-loaded MemoryEntry[] is already scoped, so it is ignored there. */
+ * `tenantId` applies only on the root-string overload; a pre-loaded MemoryEntry[] is already scoped, so it is
+ * ignored there. */
 export function deduplicateLesson(hippoRootOrEntries, lesson, threshold = 0.7, tenantId) {
-    const entries = Array.isArray(hippoRootOrEntries)
-        ? hippoRootOrEntries
-        : loadAllEntries(hippoRootOrEntries, tenantId);
-    for (const entry of entries) {
-        const overlap = textOverlap(lesson, entry.content);
-        if (overlap > threshold)
-            return true;
-    }
-    return false;
+    if (Array.isArray(hippoRootOrEntries))
+        return overlapsAny(hippoRootOrEntries, lesson, threshold);
+    return isDuplicateLesson(localFilesAt(hippoRootOrEntries).learning, lesson, threshold, tenantId);
+}
+/** deduplicateLesson against the memories `learning` holds. */
+function isDuplicateLesson(learning, lesson, threshold = 0.7, tenantId) {
+    return overlapsAny(candidateEntries(learning, lesson, threshold, tenantId), lesson, threshold);
+}
+function overlapsAny(entries, lesson, threshold) {
+    return entries.some((entry) => textOverlap(lesson, entry.content) > threshold);
 }
 /** The most stderr `runWatched` returns; the terminal still gets all of it. */
 const STDERR_TAIL_BYTES = 64 * 1024;
@@ -113,12 +129,23 @@ export class RunWatchedTimeoutError extends Error {
         this.name = 'RunWatchedTimeoutError';
     }
 }
-/** Run argv[0] with the rest as its arguments and no shell, so `;`, `&` and `$()` reach it literally; stderr streams live.
- *  Returns: { exitCode, stderr } with only the last 64 KiB of stderr; rejects with RunWatchedTimeoutError past `deadlineMs`. */
+/** Run argv[0] with the rest as its arguments and no shell, so `;`, `&` and `$()` reach it literally; stderr streams
+ * live.
+ * Returns: { exitCode, stderr } with only the last 64 KiB of stderr; rejects with RunWatchedTimeoutError past
+ * `deadlineMs`. */
 export function runWatched(argv, deadlineMs = RUN_WATCHED_DEADLINE_MS, opts = {}) {
+    if (opts.shell)
+        return runWatchedLine(argv.join(' '), deadlineMs);
+    return watchChild(spawnArgv(argv, WATCHED_SPAWN_OPTIONS), deadlineMs);
+}
+/** Run `line` as one shell command line, for text the caller wrote itself (`hippo watch --shell`); same result and
+ * deadline as runWatched. */
+export function runWatchedLine(line, deadlineMs = RUN_WATCHED_DEADLINE_MS) {
+    return watchChild(spawn(line, { ...WATCHED_SPAWN_OPTIONS, windowsHide: true, shell: true }), deadlineMs);
+}
+const WATCHED_SPAWN_OPTIONS = { stdio: ['inherit', 'inherit', 'pipe'], windowsHide: true };
+function watchChild(child, deadlineMs) {
     return new Promise((resolve, reject) => {
-        const options = { stdio: ['inherit', 'inherit', 'pipe'], windowsHide: true };
-        const child = opts.shell ? spawn(argv.join(' '), { ...options, windowsHide: true, shell: true }) : spawnArgv(argv, options);
         let tail = Buffer.alloc(0);
         child.stderr?.on('data', (chunk) => {
             tail = Buffer.concat([tail, chunk]);
@@ -126,7 +153,8 @@ export function runWatched(argv, deadlineMs = RUN_WATCHED_DEADLINE_MS, opts = {}
                 tail = tail.subarray(tail.length - STDERR_TAIL_BYTES);
             process.stderr.write(chunk);
         });
-        // SHORTCUT: kills the direct child only (the shell or cmd.exe when there is one); on Windows a grandchild can outlive it.
+        // SHORTCUT: kills the direct child only (the shell or cmd.exe when there is one); on Windows a grandchild can
+        // outlive it.
         // A process-tree kill is the upgrade path.
         const timer = setTimeout(() => {
             child.kill('SIGKILL');
@@ -155,7 +183,8 @@ export function isGitRepo(cwd) {
         return raw.trim() === 'true';
     }
     catch (err) {
-        log.debug(`autolearn: not a git repo: ${errorMessage(err)}`);
+        // Asking git about a folder that is no repo is the probe itself, so a failure is the expected answer.
+        log.debug(`autolearn: not a git repo: ${errorMessage(err)}`, errorFields(err));
         return false;
     }
 }
@@ -169,7 +198,7 @@ export function fetchGitLog(cwd, days) {
         return raw;
     }
     catch (err) {
-        log.debug(`autolearn: git log unavailable: ${errorMessage(err)}`);
+        log.warn(`autolearn: git log unavailable: ${errorMessage(err)}`, errorFields(err));
         return '';
     }
 }

package/dist/learn/churn-git.d.ts

@@ -17,6 +17,9 @@ export declare function fetchChurnWindowLog(repoRoot: string, sinceIso: string):
 export declare function gitGrepPresence(repoRoot: string, patterns: string[], rev: string): Set<string>;
 /** Last commit at or before `beforeIso`, or null when the repo has none. */
 export declare function resolveCommitBefore(repoRoot: string, beforeIso: string): string | null;
-/** package.json `scripts` at a revision; {} when the file is absent, null when unparsable. Git failures throw GitReadError. */
+/**
+ * package.json `scripts` at a revision; {} when the file is absent, null when unparsable. Git failures throw
+ * GitReadError.
+ */
 export declare function packageScriptsAt(repoRoot: string, rev: string): Record<string, string> | null;
 //# sourceMappingURL=churn-git.d.ts.map

package/dist/learn/churn-git.js

@@ -8,14 +8,21 @@ import { errorMessage } from '../util/log.js';
 import { isJsonObject, isJsonString } from '../util/json.js';
 // A `git log --name-status` dump can run to tens of MB; default 1MB pipe would truncate it.
 const GIT_MAX_BUFFER = 64 * 1024 * 1024;
-// Longer than the 10 s of one-line git reads because a full log dump on a large repo is slow, yet bounded so a wedged git cannot stall sleep.
+// Longer than the 10 s of one-line git reads because a full log dump on a large repo is slow, yet bounded so a wedged
+// git cannot stall sleep.
 const GIT_TIMEOUT_MS = MINUTE_MS;
 /** A real git failure (not git grep's expected exit-1-no-match). Callers abort the whole run on this. */
 export class GitReadError extends Error {
 }
 function runGit(args, repoRoot) {
     try {
-        return execFileSync('git', args, { cwd: repoRoot, encoding: 'utf8', maxBuffer: GIT_MAX_BUFFER, timeout: GIT_TIMEOUT_MS, windowsHide: true });
+        return execFileSync('git', args, {
+            cwd: repoRoot,
+            encoding: 'utf8',
+            maxBuffer: GIT_MAX_BUFFER,
+            timeout: GIT_TIMEOUT_MS,
+            windowsHide: true,
+        });
     }
     catch (err) {
         throw new GitReadError(`git ${args.join(' ')} failed: ${errorMessage(err)}`, { cause: err });
@@ -24,7 +31,13 @@ function runGit(args, repoRoot) {
 // git grep exits 1 for "no match" -- a normal empty result, not a failure.
 function runGitGrepOrEmpty(args, repoRoot) {
     try {
-        return execFileSync('git', args, { cwd: repoRoot, encoding: 'utf8', maxBuffer: GIT_MAX_BUFFER, timeout: GIT_TIMEOUT_MS, windowsHide: true });
+        return execFileSync('git', args, {
+            cwd: repoRoot,
+            encoding: 'utf8',
+            maxBuffer: GIT_MAX_BUFFER,
+            timeout: GIT_TIMEOUT_MS,
+            windowsHide: true,
+        });
     }
     catch (err) {
         // SAFETY: execFileSync attaches `status` to the thrown Error on a non-zero child exit.
@@ -44,7 +57,15 @@ export function fetchChurnWindowLog(repoRoot, sinceIso) {
     const buffered = new Date(new Date(sinceIso).getTime() - DAY_MS).toISOString();
     const raw = runGit(
     // --first-parent -m: a merge's changes land as one diff against its mainline parent.
-    ['log', '--no-renames', '--first-parent', '-m', `--since=${buffered}`, '--pretty=format:%x01%H%x02%cI', '--name-status'], repoRoot);
+    [
+        'log',
+        '--no-renames',
+        '--first-parent',
+        '-m',
+        `--since=${buffered}`,
+        '--pretty=format:%x01%H%x02%cI',
+        '--name-status',
+    ], repoRoot);
     const commits = [];
     let current = null;
     for (const line of raw.split('\n')) {
@@ -88,7 +109,10 @@ export function resolveCommitBefore(repoRoot, beforeIso) {
     const raw = runGit(['rev-list', '-1', '--first-parent', `--before=${beforeIso}`, 'HEAD'], repoRoot).trim();
     return raw === '' ? null : raw;
 }
-/** package.json `scripts` at a revision; {} when the file is absent, null when unparsable. Git failures throw GitReadError. */
+/**
+ * package.json `scripts` at a revision; {} when the file is absent, null when unparsable. Git failures throw
+ * GitReadError.
+ */
 export function packageScriptsAt(repoRoot, rev) {
     if (runGit(['ls-tree', '--name-only', rev, '--', 'package.json'], repoRoot).trim() === '')
         return {};

package/dist/learn/extract.d.ts

@@ -9,7 +9,10 @@ export interface ExtractOptions {
     apiKey: string;
     model?: string;
     fetcher?: typeof fetch;
-    /** Told why a call produced nothing, so callers can surface it instead of guessing; `failure` is set when the API call itself failed. */
+    /**
+     * Told why a call produced nothing, so callers can surface it instead of guessing; `failure` is set when the API call
+     * itself failed.
+     */
     onError?: (msg: string, failure?: AnthropicMessageFailure) => void;
 }
 export declare function extractFacts(text: string, opts: ExtractOptions): Promise<ExtractedFact[]>;

package/dist/learn/extract.js

@@ -1,9 +1,9 @@
 import { Layer, createMemory } from '../core/memory.js';
-import { writeEntry } from '../store/entry-writes.js';
+import { localFilesAt } from './roots.js';
 import { loadConfig } from '../core/config.js';
 import { RejectedValueError } from '../core/api-errors.js';
 import { redactSecretsStrict } from '../util/secret-detect.js';
-import { describeMessageFailure, sendAnthropicMessage } from '../util/anthropic-messages.js';
+import { describeMessageFailure, sendAnthropicMessage, } from '../util/anthropic-messages.js';
 import { neverAutoShareTags } from '../sharing/share.js';
 import { errorMessage, log } from '../util/log.js';
 import { isJsonString } from '../util/json.js';
@@ -58,13 +58,15 @@ function parseExtractedFacts(parsed) {
             break;
         if (!item ||
             !isJsonString(item.content) ||
-            item.content.length < 3)
+            item.content.length < 3) {
             continue;
+        }
         const itemTags = item.tags;
         const tags = Array.isArray(itemTags)
             ? itemTags.filter((t) => isJsonString(t))
             : [];
-        // SAFETY: the isJsonString + validValences.has guard below confirms item.valence is one of the four literal strings of EmotionalValence.
+        // SAFETY: the isJsonString + validValences.has guard below confirms item.valence is one of the four literal strings
+        // of EmotionalValence.
         const valence = isJsonString(item.valence) && validValences.has(item.valence)
             ? item.valence
             : 'neutral';
@@ -74,13 +76,17 @@ function parseExtractedFacts(parsed) {
 }
 const INHERITABLE_PREFIXES = ['conv:', 'session:', 'scope:', 'path:'];
 export function storeExtractedFacts(hippoRoot, source, facts) {
+    return storeFacts(localFilesAt(hippoRoot), source, facts);
+}
+/** storeExtractedFacts into the store `files` names. */
+function storeFacts(files, source, facts) {
     const inheritedTags = [
         ...source.tags.filter((t) => INHERITABLE_PREFIXES.some((p) => t.startsWith(p))),
         ...neverAutoShareTags([source]),
     ];
     const entries = [];
     let rejected = 0;
-    const baseHalfLifeDays = loadConfig(hippoRoot).defaultHalfLifeDays;
+    const baseHalfLifeDays = loadConfig(files.hippoRoot).defaultHalfLifeDays;
     for (const fact of facts) {
         const defect = certainDefect(fact.content);
         if (defect !== null) {
@@ -88,9 +94,10 @@ export function storeExtractedFacts(hippoRoot, source, facts) {
             continue;
         }
         const entry = buildExtractedEntry(fact, source, inheritedTags, baseHalfLifeDays);
-        // A refusal is per-VALUE: one rejected fact must not drop the rest of the batch; writeEntry already audited it (reject_refusal), so skip and count.
+        // A refusal is per-VALUE: one rejected fact must not drop the rest of the batch; writeEntry already audited it
+        // (reject_refusal), so skip and count.
         try {
-            writeEntry(hippoRoot, entry);
+            files.learning.writeEntry(entry);
         }
         catch (err) {
             if (err instanceof RejectedValueError) {
@@ -111,10 +118,10 @@ function buildExtractedEntry(fact, source, inheritedTags, baseHalfLifeDays) {
     return { ...createMemory(fact.content, {
             layer: Layer.Semantic,
             tags,
-            emotional_valence: fact.valence,
+            emotionalValence: fact.valence,
             confidence: 'inferred',
             source: source.source,
-            extracted_from: source.id,
+            extractedFrom: source.id,
             scope: source.scope,
             // Without it createMemory stamps 'default', and extracted facts leave
             // the tenant of the episodic memory they were extracted from.

package/dist/learn/forward-claim-detector.d.ts

@@ -1,12 +1,24 @@
-/** Forward-claim detector: a pure regex set plus token extraction deciding whether a recall query carries a forward-prediction phrase.
- *  Calibration is HIGH-PRECISION / LOW-RECALL, since cry-wolf noise dominates hint UX; `recall_autodebias_hint_no_class_match` audits are the telemetry. */
+/**
+ * Forward-claim detector: a pure regex set plus token extraction deciding whether a recall query carries a
+ * forward-prediction phrase.
+ * Calibration is HIGH-PRECISION / LOW-RECALL, since cry-wolf noise dominates hint UX;
+ * `recall_autodebias_hint_no_class_match` audits are the telemetry.
+ */
 export interface ForwardClaimMatch {
-    /** The regex match snippet (e.g. "will take"), surfaced in `PlanningFallacyHint.detectedPhrase` so the agent sees WHY the hint appeared. */
+    /**
+     * The regex match snippet (e.g. "will take"), surfaced in `PlanningFallacyHint.detectedPhrase` so the agent sees WHY
+     * the hint appeared.
+     */
     phrase: string;
-    /** Lower-cased non-stop-word tokens (len >= 3) from the FULL query, not just the match; the class resolver scores them against class_tag tokens. */
+    /**
+     * Lower-cased non-stop-word tokens (len >= 3) from the FULL query, not just the match; the class resolver scores them
+     * against class_tag tokens.
+     */
     classQueryTokens: string[];
 }
-/** Detect whether a recall query carries a forward-prediction phrase; returns the first-match phrase plus class-resolution tokens, else null.
+/**
+ * Detect whether a recall query carries a forward-prediction phrase; returns the first-match phrase plus
+ * class-resolution tokens, else null.
  *  Token extraction runs only on a match, so non-forward queries pay nothing beyond the regex gate. */
 export declare function detectForwardClaim(queryText: string): ForwardClaimMatch | null;
 //# sourceMappingURL=forward-claim-detector.d.ts.map

package/dist/learn/forward-claim-detector.js

@@ -1,19 +1,31 @@
-/** Forward-claim detector: a pure regex set plus token extraction deciding whether a recall query carries a forward-prediction phrase.
- *  Calibration is HIGH-PRECISION / LOW-RECALL, since cry-wolf noise dominates hint UX; `recall_autodebias_hint_no_class_match` audits are the telemetry. */
-/** Each pattern is deliberately narrow (add one only on audit evidence); word boundaries are mandatory so `ETA` never matches inside `BETAtesting`. */
-// Shared duration suffix: needs a digit + unit (`<N> unit`, `a/an unit`, `one unit`) so 'will take ownership' and 'ship in Docker' do not match.
-const DURATION_TAIL = String.raw `(?:about|around|~|≈)?\s*(?:\d+|a|an|one)\s*(?:day|week|month|hour|hr|min(?:ute)?|sec(?:ond)?)s?\b`;
+/**
+ * Forward-claim detector: a pure regex set plus token extraction deciding whether a recall query carries a
+ * forward-prediction phrase.
+ * Calibration is HIGH-PRECISION / LOW-RECALL, since cry-wolf noise dominates hint UX;
+ * `recall_autodebias_hint_no_class_match` audits are the telemetry.
+ */
+/**
+ * Each pattern is deliberately narrow (add one only on audit evidence); word boundaries are mandatory so `ETA` never
+ * matches inside `BETAtesting`.
+ */
+// Shared duration suffix: needs a digit + unit (`<N> unit`, `a/an unit`, `one unit`) so 'will take ownership' and 'ship
+// in Docker' do not match.
+const DURATION_TAIL = String.raw `(?:about|around|~|≈)?\s*(?:\d+|a|an|one)\s*` +
+    String.raw `(?:day|week|month|hour|hr|min(?:ute)?|sec(?:ond)?)s?\b`;
 const FORWARD_CLAIM_PATTERNS = [
-    // Verb + duration tail: requires `<verb> take <N> <unit>`, because a bare `will take` matched `who will take ownership of auth?`.
+    // Verb + duration tail: requires `<verb> take <N> <unit>`, because a bare `will take` matched `who will take
+    // ownership of auth?`.
     new RegExp(String.raw `\b(?:will|should|gonna|going\s+to)\s+take\s+${DURATION_TAIL}`, 'i'),
-    // Ship + by/in + duration-or-day: a bare `ship in` matched `how does this ship in Docker?`, so a duration tail or literal day-of-week is required.
+    // Ship + by/in + duration-or-day: a bare `ship in` matched `how does this ship in Docker?`, so a duration tail or
+    // literal day-of-week is required.
     new RegExp(String.raw `\bship(?:ping|s)?\s+(?:by|in)\s+(?:(?:about|around)\s+)?(?:next\s+)?` +
         String.raw `(?:${DURATION_TAIL}|(?:monday|tuesday|wednesday|thursday|friday|saturday|sunday))\b`, 'i'),
     /\bestimate(?:d)?\s+(?:at\s+)?(?:~|≈|about|around)?\s*\d+/i,
     /\b(?:by|in|within)\s+(?:about|around|~)?\s*\d+\s*(?:day|week|month|hour)s?\b/i,
     /\bETA\s*(?:is|:)?\s*\d+/i,
     /\b(?:by|before)\s+next\s+(?:week|month|sprint|monday|tuesday|wednesday|thursday|friday|saturday|sunday)\b/i,
-    // Standalone tilde duration ('~3 days for migration'): the lookbehind asserts start-of-string or whitespace because `\b` before `~` needs a word char
+    // Standalone tilde duration ('~3 days for migration'): the lookbehind asserts start-of-string or whitespace because
+    // `\b` before `~` needs a word char
     // and /\b~/ would only match 'foo~3 days', silently missing the real cases.
     /(?<=^|\s)~\s*\d+\s*(?:day|week|month|hour)s?\b/i,
     // Should + verb + duration tail. Same tightening as the leading 'will
@@ -21,22 +33,29 @@ const FORWARD_CLAIM_PATTERNS = [
     new RegExp(String.raw `\bshould\s+(?:be|ship|finish|complete|land)\s+(?:by|in|within)\s+(?:(?:about|around)\s+)?(?:next\s+)?` +
         String.raw `(?:${DURATION_TAIL}|(?:monday|tuesday|wednesday|thursday|friday|saturday|sunday))\b`, 'i'),
 ];
-/** Pronouns, function words and modal verbs the regex set already gates on; dropped before class resolution so overlap comes from domain tokens. */
+/**
+ * Pronouns, function words and modal verbs the regex set already gates on; dropped before class resolution so overlap
+ * comes from domain tokens.
+ */
 const STOP_WORDS = new Set([
     'the', 'a', 'an', 'and', 'or', 'but', 'for', 'to', 'in', 'on', 'at', 'of',
     'by', 'with', 'my', 'your', 'our', 'their', 'its', 'it', 'this', 'that',
     'these', 'those', 'will', 'should', 'can', 'i', 'we', 'they', 'he', 'she',
     'is', 'be', 'was', 'are', 'were', 'has', 'have', 'had', 'do', 'does', 'did',
     'from', 'as', 'so', 'than', 'then',
-    // Verbs inside FORWARD_CLAIM_PATTERNS gate the regex but are no signal for class resolution; listing them keeps them out of the classQueryTokens overlap.
+    // Verbs inside FORWARD_CLAIM_PATTERNS gate the regex but are no signal for class resolution; listing them keeps them
+    // out of the classQueryTokens overlap.
     'take', 'taken', 'takes', 'ship', 'ships', 'finish', 'complete', 'land',
     'eta', 'estimate', 'estimated', 'next', 'about', 'around',
-    // Every forward-claim phrase contains a duration unit by design; letting it through would let a class tag containing 'days' win or tie on the unit.
+    // Every forward-claim phrase contains a duration unit by design; letting it through would let a class tag containing
+    // 'days' win or tie on the unit.
     'day', 'days', 'week', 'weeks', 'month', 'months',
     'hour', 'hours', 'hr', 'hrs',
     'min', 'mins', 'minute', 'minutes', 'sec', 'secs', 'second', 'seconds',
 ]);
-/** Detect whether a recall query carries a forward-prediction phrase; returns the first-match phrase plus class-resolution tokens, else null.
+/**
+ * Detect whether a recall query carries a forward-prediction phrase; returns the first-match phrase plus
+ * class-resolution tokens, else null.
  *  Token extraction runs only on a match, so non-forward queries pay nothing beyond the regex gate. */
 export function detectForwardClaim(queryText) {
     if (!queryText)
@@ -51,12 +70,12 @@ export function detectForwardClaim(queryText) {
     return null;
 }
 function extractClassQueryTokens(queryText) {
-    return queryText
+    return (queryText
         .toLowerCase()
         // Strip everything that's not alphanum or whitespace or hyphen / underscore.
         .replace(/[^a-z0-9\s_-]/g, ' ')
-        // Split on whitespace, hyphen and underscore so `migration-effort` yields ['migration', 'effort'], matching the class-tag split in resolveClassFromTokens.
+        // Split on whitespace, hyphen and underscore, matching the class-tag split in resolveClassFromTokens.
         .split(/[\s_-]+/)
-        .filter((t) => t.length >= 3 && !STOP_WORDS.has(t) && !/^\d+$/.test(t));
+        .filter((t) => t.length >= 3 && !STOP_WORDS.has(t) && !/^\d+$/.test(t)));
 }
 //# sourceMappingURL=forward-claim-detector.js.map

package/dist/learn/invalidation.d.ts

@@ -1,4 +1,4 @@
-import { type HippoStore } from '../store/port.js';
+import type { StoreWith } from '../store/index.js';
 import { type MemoryEntry } from '../core/memory.js';
 export interface InvalidationTarget {
     from: string;
@@ -24,18 +24,23 @@ export interface InvalidationOptions {
 /** Extract what was replaced/removed from a commit message.
  *  Returns null if the commit isn't a breaking/migration change. */
 export declare function extractInvalidationTarget(message: string): InvalidationTarget | null;
-/** Find memories that reference the invalidated pattern and weaken them (halve half_life_days, confidence 'stale', add 'invalidated' tag; pinned are skipped).
- *  Tag matching is EXACT: the FULL pattern must equal a tag, so a pattern merely containing a common tag word cannot mass-weaken every memory with that tag. */
+/** Find memories that reference the invalidated pattern and weaken them (halve half_life_days, confidence 'stale', add
+ * 'invalidated' tag; pinned are skipped).
+ * Tag matching is EXACT: the FULL pattern must equal a tag, so a pattern merely containing a common tag word cannot
+ * mass-weaken every memory with that tag. */
 export declare function invalidateMatching(hippoRoot: string, target: InvalidationTarget, tenantId?: string, options?: InvalidationOptions): InvalidationResult;
-/** invalidateMatching for a batch: matches against `live`, the caller's list of the tenant's rows, and keeps it current.
- *  Each match is read again before it is weakened, so a row another writer changed since the list was read is never written back stale. */
-export declare function invalidateMatchingAmong(store: HippoStore, live: MemoryEntry[], target: InvalidationTarget, tenantId?: string): Promise<InvalidationResult>;
+/** invalidateMatching for a batch: matches against `live`, the caller's list of the tenant's rows, and keeps it
+ * current.
+ * Each match is read again before it is weakened, so a row another writer changed since the list was read is never
+ * written back stale. */
+export declare function invalidateMatchingAmong(store: StoreWith<'lessonWrites'>, live: MemoryEntry[], target: InvalidationTarget, tenantId?: string): Promise<InvalidationResult>;
 export interface ChurnRefs {
     paths: string[];
     symbols: string[];
     scripts: string[];
 }
-/** Pure syntactic extraction; repo-aware resolution (trackedness, path relativization) happens only in detectChurnStale. */
+/** Pure syntactic extraction; repo-aware resolution (trackedness, path relativization) happens only in
+ * detectChurnStale. */
 export declare function extractChurnRefs(content: string): ChurnRefs;
 export interface DetectChurnStaleOptions {
     tenantId: string;