hippo-memory 1.62.0 → 1.63.0

package/dist/project-remote.js

@@ -0,0 +1,138 @@
+// A checkout's `origin` remote, read from its git config file and normalised into a project id; no git process, so the prompt hook can call it.
+import * as fs from 'fs';
+import * as path from 'path';
+import { isObjectLike, isStringValue } from './capture-contract.js';
+import { log } from './log.js';
+/** The config file git reads for a checkout: `.git/config`, a linked worktree's `<commondir>/config`, a submodule's `<gitdir>/config`. */
+export function gitConfigPath(gitRoot) {
+    const marker = path.join(gitRoot, '.git');
+    try {
+        if (fs.statSync(marker).isDirectory())
+            return path.join(marker, 'config');
+        const gitDir = /^gitdir:\s*(.+)$/m.exec(fs.readFileSync(marker, 'utf8'))?.[1]?.trim();
+        if (!gitDir)
+            return null;
+        const linkDir = path.resolve(gitRoot, gitDir);
+        const commondir = path.join(linkDir, 'commondir');
+        if (!fs.existsSync(commondir))
+            return path.join(linkDir, 'config');
+        return path.join(path.resolve(linkDir, fs.readFileSync(commondir, 'utf8').trim()), 'config');
+    }
+    catch (err) {
+        log.debug(`project remote: no git config for ${gitRoot}: ${err instanceof Error ? err.message : String(err)}`);
+        return null;
+    }
+}
+/** One config value with git's quoting: `"` toggles quoting, backslash escapes, and an unquoted `#` or `;` starts a comment. */
+function configValue(raw) {
+    let out = '';
+    let quoted = false;
+    for (let i = 0; i < raw.length; i++) {
+        const c = raw[i];
+        if (c === '\\' && i + 1 < raw.length) {
+            const next = raw[++i];
+            out += next === 'n' ? '\n' : next === 't' ? '\t' : next === 'b' ? '' : next;
+        }
+        else if (c === '"') {
+            quoted = !quoted;
+        }
+        else if (!quoted && (c === '#' || c === ';')) {
+            break;
+        }
+        else {
+            out += c;
+        }
+    }
+    return out.trim();
+}
+const SECTION = /^\[\s*([A-Za-z0-9.-]+)(?:\s+"((?:[^"\\]|\\.)*)")?\s*\](.*)$/;
+const ENTRY = /^([A-Za-z][A-Za-z0-9-]*)\s*(?:=(.*))?$/;
+/** `remote.origin.url` from a config file's text, the first value as git fetch uses; the subsection name is case-sensitive. */
+export function originUrlFromConfig(text) {
+    let inOrigin = false;
+    for (const raw of text.split(/\r?\n/)) {
+        let line = raw.trim();
+        const section = SECTION.exec(line);
+        if (section) {
+            const [, name, sub, rest] = section;
+            inOrigin = sub === undefined
+                ? name.toLowerCase() === 'remote.origin'
+                : name.toLowerCase() === 'remote' && sub.replace(/\\(.)/g, '$1') === 'origin';
+            line = rest.trim();
+        }
+        const entry = inOrigin ? ENTRY.exec(line) : null;
+        if (entry && entry[1].toLowerCase() === 'url' && entry[2] !== undefined) {
+            const value = configValue(entry[2]);
+            if (value !== '')
+                return value;
+        }
+    }
+    return null;
+}
+/** Azure DevOps names one repo three ways; all become `dev.azure.com/org/project/repo`. */
+function azureDevOps(hostPath) {
+    const ssh = /^(?:ssh\.dev\.azure\.com|vs-ssh\.visualstudio\.com)\/v3\/(.+)$/.exec(hostPath);
+    if (ssh)
+        return `dev.azure.com/${ssh[1]}`;
+    const legacy = /^([^/.]+)\.visualstudio\.com\/(?:defaultcollection\/)?(.+)$/.exec(hostPath);
+    const https = legacy ? `dev.azure.com/${legacy[1]}/${legacy[2]}` : hostPath;
+    return https.startsWith('dev.azure.com/') ? https.replace('/_git/', '/') : https;
+}
+/** `host/path` for a network remote, so ssh, scp and https forms agree; null for a local path, which would put a user path into rows. */
+export function normaliseRemote(url) {
+    // A query or fragment can carry a token (`?private_token=`) and never names the repo.
+    const u = url.trim().replace(/[?#].*$/, '');
+    if (u === '' || u.includes('::') || /^file:/i.test(u) || /^[A-Za-z]:[\\/]/.test(u) || /^[./\\~]/.test(u))
+        return null;
+    let hostPath;
+    const withScheme = /^[A-Za-z][A-Za-z0-9+.-]*:\/\/([^/]*)(.*)$/.exec(u);
+    if (withScheme) {
+        // Userinfo can hold a token, and a port differs between ssh and https.
+        hostPath = withScheme[1].replace(/^.*@/, '').replace(/:\d*$/, '') + withScheme[2];
+    }
+    else {
+        const scp = /^(?:[^@/]+@)?([^:/]+):(.*)$/.exec(u);
+        if (!scp)
+            return null;
+        hostPath = `${scp[1]}/${scp[2]}`;
+    }
+    const tidy = hostPath.toLowerCase().replace(/\\/g, '/').replace(/\/{2,}/g, '/').replace(/\/+$/, '').replace(/\.git$/, '').replace(/\/+$/, '');
+    const id = azureDevOps(tidy);
+    // A colon would break the `shared:<project>:` source format; whitespace means this was no URL; an `@` left in a path may be a credential.
+    return /^[^/]+\/./.test(id) && !/[:\s@]/.test(id) ? id : null;
+}
+/** The normalised origin of the checkout rooted at gitRoot, or null when it has none a project can be named by. */
+export function originRemoteId(gitRoot) {
+    const file = gitConfigPath(gitRoot);
+    if (file === null)
+        return null;
+    try {
+        const url = originUrlFromConfig(fs.readFileSync(file, 'utf8'));
+        return url === null ? null : normaliseRemote(url);
+    }
+    catch (err) {
+        log.debug(`project remote: ${file} not read: ${err instanceof Error ? err.message : String(err)}`);
+        return null;
+    }
+}
+export const PROJECT_FILE = '.hippo-project.json';
+/** The `id` a team committed in `.hippo-project.json` at root, lowercased like every project name; null when absent or unusable. */
+export function projectFileId(root) {
+    const file = path.join(root, PROJECT_FILE);
+    if (!fs.existsSync(file))
+        return null;
+    try {
+        const parsed = JSON.parse(fs.readFileSync(file, 'utf8'));
+        const raw = isObjectLike(parsed) && 'id' in parsed ? parsed.id : undefined;
+        const id = isStringValue(raw) ? raw.trim().toLowerCase() : '';
+        // No slash: a committed file in an untrusted clone must not claim a remote-shaped id like `github.com/acme/api`.
+        if (id !== '' && id.length <= 200 && !/[:\s/\\]/.test(id))
+            return id;
+        log.warn(`${file}: "id" must be a non-empty string with no colon, slash or spaces; using the remote or folder name instead`);
+    }
+    catch (err) {
+        log.warn(`${file} not read: ${err instanceof Error ? err.message : String(err)}; using the remote or folder name instead`);
+    }
+    return null;
+}
+//# sourceMappingURL=project-remote.js.map

package/dist/prompt-recall.js

@@ -1,5 +1,4 @@
-/** Z1: recall gated on the hook prompt, not the five newest memories (pure, no I/O).
- *  See docs/plans/2026-09-26-z1-prompt-recall.md. */
+/** Recall gated on the hook prompt, not the five newest memories (pure, no I/O). */
 import { tokenize } from './tokenize.js';
 import { STOP_WORDS } from './audit.js';
 // Latency bound, not tuned: fixed in the prereg regardless of gate config.

package/dist/rate-limit.d.ts

@@ -1,7 +1,7 @@
 /**
  * Per-key token-bucket rate limiter for inbound /v1/* requests.
  *
- * Bounds api-key-id enumeration (the v0.40 follow-up noted in auth.ts): a
+ * Bounds api-key-id enumeration: a
  * client that drains its bucket is denied until it refills. Dependency-free
  * and unit-testable in isolation via the injectable `now`.
  */

package/dist/rate-limit.js

@@ -1,7 +1,7 @@
 /**
  * Per-key token-bucket rate limiter for inbound /v1/* requests.
  *
- * Bounds api-key-id enumeration (the v0.40 follow-up noted in auth.ts): a
+ * Bounds api-key-id enumeration: a
  * client that drains its bucket is denied until it refills. Dependency-free
  * and unit-testable in isolation via the injectable `now`.
  */

package/dist/raw-archive.d.ts

@@ -11,5 +11,14 @@ export interface ArchiveOpts {
      */
     afterArchive?: (db: DatabaseSyncLike, archivedMemoryId: string) => void;
 }
+/**
+ * The only legitimate path to remove a `kind='raw'` row from `memories`.
+ *
+ * Snapshots the full row into `raw_archive`, flips `kind` to `'archived'` so the
+ * append-only trigger lets the delete through, then deletes the row. All in one
+ * SAVEPOINT so it can be nested inside an outer transaction (e.g. batchWriteAndDelete).
+ *
+ * Throws if the row does not exist or is not `kind='raw'`.
+ */
 export declare function archiveRawMemory(db: DatabaseSyncLike, id: string, opts: ArchiveOpts): void;
 //# sourceMappingURL=raw-archive.d.ts.map

package/dist/raw-archive.js

@@ -2,7 +2,7 @@ import { BadRequestError, NotFoundError } from './api-errors.js';
 import { isFtsAvailable } from './db.js';
 import { appendAuditEvent, reportAuditWriteFailure } from './audit.js';
 import { markSummaryDirtyInTx } from './summary-dirty.js';
-export function archiveRawMemory(db, id, opts) {
+function loadRawRow(db, id) {
     // SAFETY: SELECT * FROM memories returns every column of the memories table; only
     // kind, tenant_id, and dag_parent_id are read below, all guaranteed present (possibly
     // null) by the memories schema.
@@ -12,65 +12,82 @@ export function archiveRawMemory(db, id, opts) {
     if (row.kind !== 'raw') {
         throw new BadRequestError(`memory ${id} is not raw (kind=${String(row.kind)})`);
     }
+    return row;
+}
+function moveRowToArchive(db, id, row, opts) {
+    // GDPR: raw_archive stores ONLY metadata, not the original
+    // memory content. The audit_log row appended below carries op='archive_raw'
+    // for the compliance audit trail. True right-to-be-forgotten — the original
+    // content is unrecoverable from raw_archive after this point.
+    const archivedAt = new Date().toISOString();
+    const redactedPayload = JSON.stringify({
+        redacted: true,
+        archived_at: archivedAt,
+        tenant_id: row.tenant_id ?? 'default',
+        kind: row.kind,
+        reason: opts.reason,
+    });
+    db.prepare(`INSERT INTO raw_archive (memory_id, archived_at, reason, archived_by, payload_json) VALUES (?, ?, ?, ?, ?)`).run(id, archivedAt, opts.reason, opts.who, redactedPayload);
+    // Flip kind to 'archived' so the BEFORE DELETE trigger no longer fires, then delete.
+    db.prepare(`UPDATE memories SET kind = 'archived' WHERE id = ?`).run(id);
+    db.prepare(`DELETE FROM memories WHERE id = ?`).run(id);
+    // FTS5 is a virtual table — no FK CASCADE applies. Purge the FTS row so the
+    // archived content is not searchable after archive. Without this the original
+    // raw text remains in memories_fts until the next DB-open backfill, defeating
+    // GDPR right-to-be-forgotten.
+    if (isFtsAvailable(db)) {
+        try {
+            db.prepare(`DELETE FROM memories_fts WHERE id = ?`).run(id);
+        }
+        catch {
+            // Best effort only. The DELETE on memories already succeeded; FTS will
+            // self-heal on next DB open via backfillFtsIndex.
+        }
+    }
+}
+// Emit the archive_raw audit event inside the SAVEPOINT so the audit row is
+// committed atomically with the row deletion. Use the row's own tenant_id
+// (fetched above as part of SELECT *), not the env. Archives must be
+// attributed to the tenant that owns the row, not whatever HIPPO_TENANT
+// happens to be set to in the calling shell.
+function auditArchive(db, id, row, opts) {
+    try {
+        appendAuditEvent(db, {
+            tenantId: String(row.tenant_id ?? 'default'),
+            actor: opts.who || 'cli',
+            op: 'archive_raw',
+            targetId: id,
+            metadata: { reason: opts.reason },
+        });
+    }
+    catch (error) {
+        // The archive itself has already succeeded; an unwritable audit table must not undo it.
+        reportAuditWriteFailure('archive_raw', String(error), id);
+    }
+}
+/**
+ * The only legitimate path to remove a `kind='raw'` row from `memories`.
+ *
+ * Snapshots the full row into `raw_archive`, flips `kind` to `'archived'` so the
+ * append-only trigger lets the delete through, then deletes the row. All in one
+ * SAVEPOINT so it can be nested inside an outer transaction (e.g. batchWriteAndDelete).
+ *
+ * Throws if the row does not exist or is not `kind='raw'`.
+ */
+export function archiveRawMemory(db, id, opts) {
+    const row = loadRawRow(db, id);
     // SAVEPOINT (not BEGIN) so this works whether or not we're already inside a
     // transaction. SQLite refuses BEGIN within a transaction; SAVEPOINT nests safely.
     db.exec('SAVEPOINT archive_raw');
     try {
-        // GDPR Path A (v0.39): raw_archive stores ONLY metadata, not the original
-        // memory content. The audit_log row appended below carries op='archive_raw'
-        // for the compliance audit trail. True right-to-be-forgotten — the original
-        // content is unrecoverable from raw_archive after this point.
-        const archivedAt = new Date().toISOString();
-        const redactedPayload = JSON.stringify({
-            redacted: true,
-            archived_at: archivedAt,
-            tenant_id: row.tenant_id ?? 'default',
-            kind: row.kind,
-            reason: opts.reason,
-        });
-        db.prepare(`INSERT INTO raw_archive (memory_id, archived_at, reason, archived_by, payload_json) VALUES (?, ?, ?, ?, ?)`).run(id, archivedAt, opts.reason, opts.who, redactedPayload);
-        // Flip kind to 'archived' so the BEFORE DELETE trigger no longer fires, then delete.
-        db.prepare(`UPDATE memories SET kind = 'archived' WHERE id = ?`).run(id);
-        db.prepare(`DELETE FROM memories WHERE id = ?`).run(id);
-        // FTS5 is a virtual table — no FK CASCADE applies. Purge the FTS row so the
-        // archived content is not searchable after archive. Without this the original
-        // raw text remains in memories_fts until the next DB-open backfill, defeating
-        // GDPR right-to-be-forgotten.
-        if (isFtsAvailable(db)) {
-            try {
-                db.prepare(`DELETE FROM memories_fts WHERE id = ?`).run(id);
-            }
-            catch {
-                // Best effort only. The DELETE on memories already succeeded; FTS will
-                // self-heal on next DB open via backfillFtsIndex.
-            }
-        }
-        // A5 audit: emit archive_raw event inside the SAVEPOINT so the audit row is
-        // committed atomically with the row deletion. Use the row's own tenant_id
-        // (fetched above as part of SELECT *), not the env. Archives must be
-        // attributed to the tenant that owns the row, not whatever HIPPO_TENANT
-        // happens to be set to in the calling shell.
-        try {
-            appendAuditEvent(db, {
-                tenantId: String(row.tenant_id ?? 'default'),
-                actor: opts.who || 'cli',
-                op: 'archive_raw',
-                targetId: id,
-                metadata: { reason: opts.reason },
-            });
-        }
-        catch (error) {
-            // The archive itself has already succeeded; an unwritable audit table must not undo it.
-            reportAuditWriteFailure('archive_raw', String(error), id);
-        }
-        // v0.30 / E2 — DAG live-coupling: archive of a child under a level-2
-        // summary marks parent dirty. Inside the SAVEPOINT so the dirty-mark
-        // commits atomically with the archive. row.dag_parent_id was fetched
-        // via SELECT * at L28 (schema v28 includes it).
+        moveRowToArchive(db, id, row, opts);
+        auditArchive(db, id, row, opts);
+        // Archiving a child under a level-2 summary marks the parent dirty, inside the
+        // SAVEPOINT so the dirty-mark commits atomically with the archive.
         if (row.dag_parent_id) {
             markSummaryDirtyInTx(db, String(row.dag_parent_id), String(row.tenant_id ?? 'default'), opts.who || 'cli');
         }
-        // afterArchive hook (v0.39 commit 3): connector-level idempotency markers
+        // afterArchive hook: connector-level idempotency markers
         // (e.g. slack_event_log) must commit atomically with the archive itself.
         // Throwing here rolls back the entire SAVEPOINT — both the archive and any
         // hook side effects. The hook runs INSIDE the SAVEPOINT so its writes

package/dist/recall-history.d.ts

@@ -1,21 +1,20 @@
 /**
- * J1 anchoring detector (recall-recurrence) — pure module.
+ * Anchoring detector (recall-recurrence), pure module.
  *
- * Implements two detection rules from ROADMAP-RESEARCH.md L546:
- *   R1 query_repeat: same queryHash within recentRepeatWindow returned
+ * Implements two detection rules:
+ *   query_repeat: same queryHash within recentRepeatWindow returned
  *     same topMemoryId (caller is re-asking the same question).
- *   R2 memory_dominance: same topMemoryId across >= minDominance distinct
+ *   memory_dominance: same topMemoryId across >= minDominance distinct
  *     queryHashes (memory acts as a fixed-point anchor regardless of what
  *     the agent asks).
  *
- * Per the plan v3 architectural decision: each pipeline (api.recall via
+ * Each pipeline (api.recall via
  * HTTP, cmdRecall, MCP hippo_recall) owns its OWN ring buffer Map keyed
  * by (tenant, session). No cross-pipeline sharing (the typical multi-
  * process deployment makes IPC ring-sharing impractical; per-pipeline
  * is correct because each pipeline has its own top-1 ranking anyway).
  *
- * Plan: docs/plans/2026-05-26-j1-anchoring-detector.md.
- * Composes with J3.2: AnchoringHint + PlanningFallacyHint are independent
+ * AnchoringHint + PlanningFallacyHint are independent
  * signals; both can fire on the same recall.
  */
 export type AnchoringReason = 'query_repeat' | 'memory_dominance';
@@ -36,20 +35,20 @@ export interface RecallHistoryEntry {
     queryHash: number;
     /** Top-1 memory id this recall surfaced; null if zero results. */
     topMemoryId: string | null;
-    /** ISO-8601 timestamp; advisory, not used by R1/R2 logic. */
+    /** ISO-8601 timestamp; advisory, not used by the detection rules. */
     ts: string;
     /** Memory id of the AnchoringHint that fired on this recall, if any.
-     *  Used by R1/R2 cooldown logic to prevent re-emitting the same hint on
+     *  Used by the cooldown logic to prevent re-emitting the same hint on
      *  consecutive recalls within the dominance window. Caller-written
      *  AFTER detectAnchoring returns; reads next time detectAnchoring runs. */
     anchoredOn?: string;
 }
 export type RecallHistorySnapshot = readonly RecallHistoryEntry[];
 export interface DetectAnchoringOpts {
-    /** R2 threshold: number of distinct queryHashes that must have returned
+    /** memory_dominance threshold: number of distinct queryHashes that must have returned
      *  the same topMemoryId. Default 3. */
     minDominance?: number;
-    /** R1 window: how many recent history entries to scan for query repeat.
+    /** query_repeat window: how many recent history entries to scan for query repeat.
      *  Default 5. */
     recentRepeatWindow?: number;
     /** Cooldown: if the immediately-prior fire (per `anchoredOn`) was for
@@ -63,8 +62,8 @@ export interface DetectAnchoringOpts {
  * sort tokens → join → FNV-1a 32-bit.
  *
  * Token sort + dedup means semantically-equivalent queries with reordered
- * words collide intentionally (the roadmap's "semantically-distinct" v1
- * uses textual normalization; embedding-based distinctness is J1-v2).
+ * words collide intentionally ("semantically-distinct" is approximated by
+ * textual normalization, not embeddings).
  *
  * Deterministic across processes; stable across Node + V8 versions.
  */
@@ -73,17 +72,17 @@ export declare function hashQueryText(query: string): number;
  * Detect anchoring patterns in the recall history against the current
  * recall's (queryHash, topMemoryId).
  *
- * Rule precedence: R2 (memory_dominance) wins on tie. When both R1 and R2
- * fire on the same recall, return only the R2 hint — R2's signal is the
- * cognitively stronger one (a memory dominating multiple DIFFERENT queries
- * is a fixed-point anchor; R1 alone is just a literal re-ask).
+ * Rule precedence: memory_dominance wins on tie. When both rules fire on the
+ * same recall, return only memory_dominance, the stronger signal (a memory
+ * dominating multiple DIFFERENT queries is a fixed-point anchor; query_repeat
+ * alone is just a literal re-ask).
  *
  * Cooldown: if the immediately-prior recall fired a hint on the SAME
  * topMemoryId within `cooldown=3` history entries, suppress. Prevents
  * spam when the agent repeatedly recalls within the dominance window.
- * Cooldown is per-memory, not per-rule: if R2 fired on M (cooldown
- * engaged for M), and the next recall has top=N + repeated query →
- * R1 fires on N (different memory, not in cooldown).
+ * Cooldown is per-memory, not per-rule: if memory_dominance fired on M
+ * (cooldown engaged for M), and the next recall has top=N + repeated query,
+ * query_repeat fires on N (different memory, not in cooldown).
  *
  * @returns AnchoringHint when a pattern fires; null otherwise.
  */

package/dist/recall-history.js

@@ -1,21 +1,20 @@
 /**
- * J1 anchoring detector (recall-recurrence) — pure module.
+ * Anchoring detector (recall-recurrence), pure module.
  *
- * Implements two detection rules from ROADMAP-RESEARCH.md L546:
- *   R1 query_repeat: same queryHash within recentRepeatWindow returned
+ * Implements two detection rules:
+ *   query_repeat: same queryHash within recentRepeatWindow returned
  *     same topMemoryId (caller is re-asking the same question).
- *   R2 memory_dominance: same topMemoryId across >= minDominance distinct
+ *   memory_dominance: same topMemoryId across >= minDominance distinct
  *     queryHashes (memory acts as a fixed-point anchor regardless of what
  *     the agent asks).
  *
- * Per the plan v3 architectural decision: each pipeline (api.recall via
+ * Each pipeline (api.recall via
  * HTTP, cmdRecall, MCP hippo_recall) owns its OWN ring buffer Map keyed
  * by (tenant, session). No cross-pipeline sharing (the typical multi-
  * process deployment makes IPC ring-sharing impractical; per-pipeline
  * is correct because each pipeline has its own top-1 ranking anyway).
  *
- * Plan: docs/plans/2026-05-26-j1-anchoring-detector.md.
- * Composes with J3.2: AnchoringHint + PlanningFallacyHint are independent
+ * AnchoringHint + PlanningFallacyHint are independent
  * signals; both can fire on the same recall.
  */
 import { envAnchoringOff, envAvailabilityOff } from './env.js';
@@ -31,44 +30,27 @@ const DEFAULT_COOLDOWN = 3;
  * sort tokens → join → FNV-1a 32-bit.
  *
  * Token sort + dedup means semantically-equivalent queries with reordered
- * words collide intentionally (the roadmap's "semantically-distinct" v1
- * uses textual normalization; embedding-based distinctness is J1-v2).
+ * words collide intentionally ("semantically-distinct" is approximated by
+ * textual normalization, not embeddings).
  *
  * Deterministic across processes; stable across Node + V8 versions.
  */
 export function hashQueryText(query) {
     if (!query)
         return 0;
-    // Token dedup before join: the R2 contract says "distinct queries"
-    // means semantically distinct, so `foo bar` and `foo foo bar` should
-    // collapse to the same hash. Without dedup, simple phrasing
-    // variations (typos, doubled tokens, intensifiers) would inflate
-    // distinct-query counts and trip R2 on essentially the same question.
-    // Codex round-1 catch.
-    // Unicode-aware tokenization (codex round-3 P2 catch): the prior
-    // ASCII-only [^a-z0-9\s] pattern stripped every non-Latin letter, so
-    // Japanese, Arabic, Cyrillic, accented-Latin etc. queries collapsed
-    // to empty token set -> hash 0 -> false R1 collisions across distinct
-    // non-English queries. \p{L} = any Unicode letter, \p{N} = any Unicode
-    // number, \p{M} = combining marks (preserve composed accented chars).
-    // Requires the /u flag and Node >= 12.
+    // Tokens are deduped before join so `foo foo bar` and `foo bar` count as one query for memory_dominance.
+    // Unicode classes (\p{L} letter, \p{N} number, \p{M} combining mark; needs /u) keep
+    // non-Latin queries from collapsing to an empty token set and colliding at hash 0.
     const normalized = query
         .toLowerCase()
         .replace(/[^\p{L}\p{N}\p{M}\s]/gu, ' ')
         .split(/\s+/)
         .filter((t) => t.length > 0);
-    // Drop tokens shorter than 3 chars to match the normalizer contract
-    // (filler / stop words). Without this, `a login bug` vs `login bug`
-    // hash differently and inflate R2 distinct-query counts, firing
-    // memory_dominance on repeated phrasings of the same question.
-    // Codex round-4 P2 catch. Matches the same >=3 filter in
-    // src/forward-claim-detector.ts for class-resolver tokens.
+    // Drop tokens under 3 chars (filler words) so `a login bug` and `login bug` hash
+    // alike; matches the >=3 filter in src/forward-claim-detector.ts.
     const filtered = normalized.filter((t) => t.length >= 3);
-    // Fallback when the >=3 filter would collapse the entire query to
-    // empty: CJK queries like `测试` / `环境` are 2-char tokens; English
-    // acronyms like `AI` / `UI` are 2 chars. Without this fallback they
-    // all hash to fnv1a32(''), producing false R1 collisions across
-    // distinct short-token queries. Codex round-5 P2 catch.
+    // Fall back to all tokens when the filter empties the query (CJK 2-char words,
+    // acronyms like `AI`) so distinct short queries do not all hash to fnv1a32('').
     const tokens = filtered.length > 0 ? filtered : normalized;
     const deduped = Array.from(new Set(tokens)).sort();
     return fnv1a32(deduped.join(' '));
@@ -91,17 +73,17 @@ function fnv1a32(text) {
  * Detect anchoring patterns in the recall history against the current
  * recall's (queryHash, topMemoryId).
  *
- * Rule precedence: R2 (memory_dominance) wins on tie. When both R1 and R2
- * fire on the same recall, return only the R2 hint — R2's signal is the
- * cognitively stronger one (a memory dominating multiple DIFFERENT queries
- * is a fixed-point anchor; R1 alone is just a literal re-ask).
+ * Rule precedence: memory_dominance wins on tie. When both rules fire on the
+ * same recall, return only memory_dominance, the stronger signal (a memory
+ * dominating multiple DIFFERENT queries is a fixed-point anchor; query_repeat
+ * alone is just a literal re-ask).
  *
  * Cooldown: if the immediately-prior recall fired a hint on the SAME
  * topMemoryId within `cooldown=3` history entries, suppress. Prevents
  * spam when the agent repeatedly recalls within the dominance window.
- * Cooldown is per-memory, not per-rule: if R2 fired on M (cooldown
- * engaged for M), and the next recall has top=N + repeated query →
- * R1 fires on N (different memory, not in cooldown).
+ * Cooldown is per-memory, not per-rule: if memory_dominance fired on M
+ * (cooldown engaged for M), and the next recall has top=N + repeated query,
+ * query_repeat fires on N (different memory, not in cooldown).
  *
  * @returns AnchoringHint when a pattern fires; null otherwise.
  */
@@ -119,7 +101,7 @@ export function detectAnchoring(history, currentQueryHash, currentTopMemoryId, o
             return null;
         }
     }
-    // R2 check FIRST (wins on tie). Count distinct queryHashes in history
+    // memory_dominance check FIRST (wins on tie). Count distinct queryHashes in history
     // where topMemoryId === currentTopMemoryId (excluding null tops).
     const matchingQueryHashes = new Set();
     for (const entry of history) {
@@ -139,7 +121,7 @@ export function detectAnchoring(history, currentQueryHash, currentTopMemoryId, o
             source: 'j1-recurrence',
         };
     }
-    // R1 check: is currentQueryHash present in the last `recentRepeatWindow`
+    // query_repeat check: is currentQueryHash present in the last `recentRepeatWindow`
     // entries AND was that entry's topMemoryId === currentTopMemoryId?
     const r1Slice = history.slice(-recentRepeatWindow);
     for (const entry of r1Slice) {

package/dist/recall-pipeline.js

@@ -11,6 +11,7 @@ import { DEFAULT_GRAPH_STREAM_WEIGHT } from './graph-stream.js';
 import { Layer } from './memory.js';
 import { multihopSearch } from './multihop.js';
 import { passesCliRecallScopeFilter } from './recall-scope.js';
+import { currentEntries } from './search/as-of.js';
 import { hybridSearch } from './search/hybrid.js';
 import { physicsSearch } from './search/physics-search.js';
 import { searchBothHybrid } from './shared.js';
@@ -72,36 +73,11 @@ function loadRecallPool(ctx, opts) {
     const passes = (e) => passesCliRecallScopeFilter(e.scope ?? null, requested);
     local = local.filter(passes);
     global = global.filter(passes);
-    if (opts.asOf) {
-        local = currentAsOf(local, opts.asOf);
-        global = currentAsOf(global, opts.asOf);
-    }
-    else if (!opts.includeSuperseded) {
-        local = local.filter((e) => !e.superseded_by);
-        global = global.filter((e) => !e.superseded_by);
-    }
+    const currentness = { asOf: opts.asOf, includeSuperseded: opts.includeSuperseded };
+    local = currentEntries(local, currentness);
+    global = currentEntries(global, currentness);
     return { local, global, total, dropped: total - (local.length + global.length) };
 }
-/** Rows that were true at `asOf`: valid by then, and not yet replaced by a successor in the same pool. */
-function currentAsOf(entries, asOf) {
-    const asOfDate = new Date(asOf);
-    const successorValidFrom = new Map();
-    for (const e of entries) {
-        if (e.superseded_by) {
-            const successor = entries.find(s => s.id === e.superseded_by);
-            if (successor)
-                successorValidFrom.set(e.id, successor.valid_from);
-        }
-    }
-    return entries.filter(e => {
-        if (new Date(e.valid_from) > asOfDate)
-            return false;
-        if (!e.superseded_by)
-            return true;
-        const succVf = successorValidFrom.get(e.id);
-        return succVf ? new Date(succVf) > asOfDate : true;
-    });
-}
 async function searchPool(ctx, opts, pool) {
     const { query, budget, cost, includeSuperseded, asOf, activeScope: scope, search } = opts;
     const { mmr, mmrLambda, minResults, explain } = search;

package/dist/recall-scope.d.ts

@@ -1,8 +1,7 @@
 /**
- * v1.25.0 — recall-side scope predicates, extracted from api.ts into a leaf
- * module so shared.ts (which api.ts imports) can apply the same default-deny
- * rule to searchBothHybrid's internal candidate loads without an import
- * cycle. Mirrors the v39 `project-identity.ts` precedent. api.ts imports
+ * Recall-side scope predicates, in a leaf module so shared.ts (which api.ts
+ * imports) can apply the same default-deny rule to searchBothHybrid's internal
+ * candidate loads without an import cycle. api.ts imports
  * these for its own call sites AND re-exports them for back-compat
  * (`api.isPrivateScope`, test imports of `passesScopeFilterForRecall`).
  */
@@ -30,7 +29,7 @@ export declare const RECALL_DEFAULT_DENY_SCOPES: readonly ["unknown:legacy"];
  */
 export declare function assertNonEmpty<T>(arr: readonly T[], name: string): void;
 /**
- * v1.2.1: source-agnostic private-scope detector. A scope string is treated
+ * Source-agnostic private-scope detector. A scope string is treated
  * as private when it has the shape `<lowercase-source>:private:<rest>`.
  *
  * Examples that match:
@@ -56,14 +55,14 @@ export declare function isPrivateScope(scope: string | null | undefined): boolea
  *   `<source>:private:*` scope and on the `RECALL_DEFAULT_DENY_SCOPES`
  *   quarantine buckets. `null` and public scopes pass.
  *
- * @internal v1.7.2 — exported for test parity with
+ * @internal Exported for test parity with
  * `RECALL_DEFAULT_DENY_SCOPES` (single-source-of-truth verification). NOT part
  * of the public API surface; not re-exported from `src/index.ts`. Subject to
  * change without semver bump.
  */
 export declare function passesScopeFilterForRecall(scope: string | null, requested: string | undefined): boolean;
 /**
- * v1.25.0 — the CLI `--scope` variant of the recall filter (JS half of the
+ * The CLI `--scope` variant of the recall filter (JS half of the
  * SQL 'default-deny-or-exact' mode in loadSearchRows).
  *
  * The CLI flag predates the envelope column as a TAG-boost ranking hint
@@ -101,7 +100,7 @@ export interface ScopeActor {
 }
 /** True when `actor` may read `scope`: admin always; member needs an exact grant on a restricted scope. */
 export declare function canReadScope(actor: ScopeActor, scope: string): boolean;
-/** Authorize an explicitly requested scope before any read honours it (ROADMAP Part VIII EI2: member scope grants). */
+/** Authorize an explicitly requested scope before any read honours it (member scope grants). */
 export declare function assertScopeRequestAllowed(actor: ScopeActor, requested: string | undefined): void;
 /** Scope a derived row keeps from one source: the restricted scope itself, else null. */
 export declare function derivationScope(scope: string | null | undefined): string | null;