hippo-memory 2.0.0 → 2.1.0

package/dist/objects/project-briefs.d.ts

@@ -1,6 +1,7 @@
 /** Project_brief object: the living, repo-scoped `summary` of a repository, evolving via supersession.
- *  `refreshBrief` assembles recent `path:<repo>` receipts with a deterministic (no-LLM) assembler; an LLM pipeline is deferred.
- *  The `project_briefs` table is the source of truth; the memory mirror (memory_id NULLABLE, ON DELETE SET NULL) is for recall. */
+ *  `refreshedBrief` assembles recent `path:<repo>` receipts with a deterministic (no-LLM) assembler; an LLM
+ *  pipeline is deferred. The `project_briefs` table is the source of truth; the memory mirror (memory_id NULLABLE,
+ *  ON DELETE SET NULL) is for recall. */
 import type { KeysetPosition } from '../util/keyset.js';
 import type { SavableDescriptor } from './descriptor.js';
 import { type ObjectSaveSite } from './lifecycle.js';
@@ -27,7 +28,7 @@ export interface SaveProjectBriefOpts {
     supersedesBriefId?: number;
     /** Extra memory tags merged after ['project_brief']. */
     extraTags?: string[];
-    /** Internal: set by refreshBrief to the receipt count so audit metadata marks the write as an auto-refresh
+    /** Internal: set by refreshedBrief to the receipt count so audit metadata marks the write as an auto-refresh
      *  without a 4th audit op. Not part of the CLI/HTTP surface. */
     refreshReceiptCount?: number;
 }
@@ -40,16 +41,16 @@ export interface ListProjectBriefsOpts {
     after?: KeysetPosition;
 }
 export declare const PROJECT_BRIEF: SavableDescriptor<'project_brief', SaveProjectBriefOpts>;
-/** Create a project_brief, or a new version superseding an existing one, in the `objects` store group's one transaction. */
-export declare function saveProjectBrief(hippoRoot: string, tenantId: string, opts: SaveProjectBriefOpts, actor?: string): ProjectBrief;
+/** Create a project_brief, or a new version superseding an
+ *  existing one, in the `objects` store group's one transaction. */
+export declare function saveProjectBrief(objects: Objects, hippoRoot: string, tenantId: string, opts: SaveProjectBriefOpts, actor?: string): Promise<ProjectBrief>;
 /** Close (retire) an active brief; a superseded row is terminal. */
-export declare function closeProjectBrief(hippoRoot: string, tenantId: string, id: number, actor?: string): ProjectBrief;
-export declare function loadProjectBriefById(hippoRoot: string, tenantId: string, id: number): ProjectBrief | null;
-export declare function loadProjectBriefs(hippoRoot: string, tenantId: string, opts?: ListProjectBriefsOpts): ProjectBrief[];
-/** Assemble the repo's recent receipts into a deterministic markdown digest and return it with the receipt count; never empty (summary is NOT NULL).
- *  The brief's own mirror (source='project_brief') is excluded; the quotes in the JSON-array LIKE are load-bearing (`hip` must not match `path:hippo`). */
-export declare function assembleBriefFromReceipts(hippoRoot: string, tenantId: string, repo: string): BriefDigest;
-/** `assembleBriefFromReceipts` over a served store's group. */
+export declare function closeProjectBrief(objects: Objects, tenantId: string, id: number, actor?: string): Promise<ProjectBrief>;
+export declare function loadProjectBriefById(objects: Objects, tenantId: string, id: number): Promise<ProjectBrief | null>;
+export declare function loadProjectBriefs(objects: Objects, tenantId: string, opts?: ListProjectBriefsOpts): Promise<ProjectBrief[]>;
+/** Assemble the repo's recent receipts into a deterministic markdown digest and return it with the receipt count;
+ *  never empty (summary is NOT NULL). The brief's own mirror (source='project_brief') is excluded; the quotes in
+ *  the JSON-array LIKE are load-bearing (`hip` must not match `path:hippo`). */
 export declare function briefFromReceipts(objects: Objects, tenantId: string, repo: string): Promise<BriefDigest>;
 export interface BriefDigest {
     markdown: string;
@@ -57,7 +58,5 @@ export interface BriefDigest {
 }
 /** Saves a new version of the repo's brief from its receipts. The receipts are read before
  * the save's transaction, so a receipt written in between shows in the next refresh. */
-export declare function refreshBrief(hippoRoot: string, tenantId: string, repo: string, actor?: string): ProjectBrief;
-/** `refreshBrief` over a served store's group. */
 export declare function refreshedBrief(objects: Objects, site: ObjectSaveSite, repo: string): Promise<ProjectBrief>;
 //# sourceMappingURL=project-briefs.d.ts.map

package/dist/objects/project-briefs.js

@@ -1,12 +1,12 @@
 /** Project_brief object: the living, repo-scoped `summary` of a repository, evolving via supersession.
- *  `refreshBrief` assembles recent `path:<repo>` receipts with a deterministic (no-LLM) assembler; an LLM pipeline is deferred.
- *  The `project_briefs` table is the source of truth; the memory mirror (memory_id NULLABLE, ON DELETE SET NULL) is for recall. */
+ *  `refreshedBrief` assembles recent `path:<repo>` receipts with a deterministic (no-LLM) assembler; an LLM
+ *  pipeline is deferred. The `project_briefs` table is the source of truth; the memory mirror (memory_id NULLABLE,
+ *  ON DELETE SET NULL) is for recall. */
 import { truncateWithEllipsis } from '../util/ellipsize.js';
 import { BadRequestError } from '../core/api-errors.js';
 import { assertTenantId } from '../store/tenant.js';
 import { checkText, requireLine } from './fields.js';
-import { closeObjectAt, listObjectsAt, objectByIdAt, saveObject, saveObjectAt } from './lifecycle.js';
-import { sqliteObjects } from '../store/sqlite/objects-group.js';
+import { closeObject, listObjects, objectById, saveObject } from './lifecycle.js';
 export const VALID_BRIEF_STATES = new Set([
     'active',
     'superseded',
@@ -58,26 +58,25 @@ export const PROJECT_BRIEF = {
 function buildBriefContent(repo, summary) {
     return `${repo}\n\n${summary}`;
 }
-/** Create a project_brief, or a new version superseding an existing one, in the `objects` store group's one transaction. */
-export function saveProjectBrief(hippoRoot, tenantId, opts, actor = 'cli') {
-    return saveObjectAt(PROJECT_BRIEF, { hippoRoot, tenantId, actor }, opts);
+/** Create a project_brief, or a new version superseding an
+ *  existing one, in the `objects` store group's one transaction. */
+export function saveProjectBrief(objects, hippoRoot, tenantId, opts, actor = 'cli') {
+    return saveObject(objects, PROJECT_BRIEF, { hippoRoot, tenantId, actor }, opts);
 }
 /** Close (retire) an active brief; a superseded row is terminal. */
-export function closeProjectBrief(hippoRoot, tenantId, id, actor = 'cli') {
-    return closeObjectAt(hippoRoot, PROJECT_BRIEF, tenantId, id, actor);
+export function closeProjectBrief(objects, tenantId, id, actor = 'cli') {
+    return closeObject(objects, PROJECT_BRIEF, tenantId, id, actor);
 }
-export function loadProjectBriefById(hippoRoot, tenantId, id) {
-    return objectByIdAt(hippoRoot, PROJECT_BRIEF, tenantId, id);
+export function loadProjectBriefById(objects, tenantId, id) {
+    return objectById(objects, PROJECT_BRIEF, tenantId, id);
 }
-export function loadProjectBriefs(hippoRoot, tenantId, opts = {}) {
-    return listObjectsAt(hippoRoot, PROJECT_BRIEF, tenantId, { status: opts.status, filter: opts.repo, limit: opts.limit, after: opts.after });
-}
-/** The repo's current active brief, or null. The DB allows several active rows per (tenant, repo); the most recent wins. */
-function loadActiveBriefForRepo(hippoRoot, tenantId, repo) {
-    assertTenantId('loadActiveBriefForRepo', tenantId);
-    if (repo === '')
-        return null;
-    return sqliteObjects(hippoRoot).listObjects(tenantId, 'project_brief', newestActive(repo))[0] ?? null;
+export function loadProjectBriefs(objects, tenantId, opts = {}) {
+    return listObjects(objects, PROJECT_BRIEF, tenantId, {
+        status: opts.status,
+        filter: opts.repo,
+        limit: opts.limit,
+        after: opts.after,
+    });
 }
 /** An empty filter lists every repo, so the callers refuse an empty repo first. */
 function newestActive(repo) {
@@ -94,8 +93,9 @@ function receiptHeadline(content) {
 function receiptTag(normalizedRepo) {
     return `path:${normalizedRepo.toLowerCase()}`;
 }
-// `id DESC` is a lexical tiebreak on a random-ish id, so same-`created` order is stable but arbitrary; `created DESC` is the recency order.
-// Receipt lines go newest-first only while they fit MAX_BRIEF_SUMMARY_LEN (reserving slack for header and omission footer), else the store rejects the body.
+// `id DESC` is a lexical tiebreak on a random-ish id, so same-`created` order is stable but arbitrary;
+// `created DESC` is the recency order. Receipt lines go newest-first only while they fit MAX_BRIEF_SUMMARY_LEN
+// (reserving slack for header and omission footer), else the store rejects the body.
 function fitReceiptLines(receipts) {
     const buildReceiptLine = (r) => `- ${(r.created ?? '').slice(0, 10)} [${r.source}] ${receiptHeadline(r.content)}`;
     const receiptLines = [];
@@ -142,16 +142,13 @@ function renderBriefDigest(normalizedRepo, receiptCount, receiptLines) {
     }
     return markdown;
 }
-/** Assemble the repo's recent receipts into a deterministic markdown digest and return it with the receipt count; never empty (summary is NOT NULL).
- *  The brief's own mirror (source='project_brief') is excluded; the quotes in the JSON-array LIKE are load-bearing (`hip` must not match `path:hippo`). */
-export function assembleBriefFromReceipts(hippoRoot, tenantId, repo) {
-    const normalizedRepo = requiredRepo('assembleBriefFromReceipts', tenantId, repo);
-    return briefDigest(normalizedRepo, sqliteObjects(hippoRoot).briefReceipts(tenantId, receiptTag(normalizedRepo), MAX_BRIEF_RECEIPTS));
-}
-/** `assembleBriefFromReceipts` over a served store's group. */
+/** Assemble the repo's recent receipts into a deterministic markdown digest and return it with the receipt count;
+ *  never empty (summary is NOT NULL). The brief's own mirror (source='project_brief') is excluded; the quotes in
+ *  the JSON-array LIKE are load-bearing (`hip` must not match `path:hippo`). */
 export async function briefFromReceipts(objects, tenantId, repo) {
     const normalizedRepo = requiredRepo('assembleBriefFromReceipts', tenantId, repo);
-    return briefDigest(normalizedRepo, await objects.briefReceipts(tenantId, receiptTag(normalizedRepo), MAX_BRIEF_RECEIPTS));
+    const receipts = await objects.briefReceipts(tenantId, receiptTag(normalizedRepo), MAX_BRIEF_RECEIPTS);
+    return briefDigest(normalizedRepo, receipts);
 }
 function requiredRepo(fn, tenantId, repo) {
     assertTenantId(fn, tenantId);
@@ -161,7 +158,10 @@ function requiredRepo(fn, tenantId, repo) {
     return normalizedRepo;
 }
 function briefDigest(normalizedRepo, receipts) {
-    return { markdown: renderBriefDigest(normalizedRepo, receipts.length, fitReceiptLines(receipts)), receiptCount: receipts.length };
+    return {
+        markdown: renderBriefDigest(normalizedRepo, receipts.length, fitReceiptLines(receipts)),
+        receiptCount: receipts.length,
+    };
 }
 /** The version a refresh saves: a successor of the repo's active brief when it has one, else a first version. */
 function refreshWrite(normalizedRepo, digest, active) {
@@ -171,19 +171,13 @@ function refreshWrite(normalizedRepo, digest, active) {
         changeSummary: active ? `auto-refresh from ${digest.receiptCount} receipt(s)` : undefined,
         supersedesBriefId: active ? active.id : undefined,
         refreshReceiptCount: digest.receiptCount,
-        // The path tag lets path-aware recall boost the brief; it cannot become its own receipt, because receipts leave out source project_brief.
+        // The path tag lets path-aware recall boost the brief; it cannot become its own receipt, because receipts
+        // leave out source project_brief.
         extraTags: [receiptTag(normalizedRepo)],
     };
 }
 /** Saves a new version of the repo's brief from its receipts. The receipts are read before
  * the save's transaction, so a receipt written in between shows in the next refresh. */
-export function refreshBrief(hippoRoot, tenantId, repo, actor = 'cli') {
-    const normalizedRepo = requiredRepo('refreshBrief', tenantId, repo);
-    const digest = assembleBriefFromReceipts(hippoRoot, tenantId, normalizedRepo);
-    const active = loadActiveBriefForRepo(hippoRoot, tenantId, normalizedRepo);
-    return saveProjectBrief(hippoRoot, tenantId, refreshWrite(normalizedRepo, digest, active), actor);
-}
-/** `refreshBrief` over a served store's group. */
 export async function refreshedBrief(objects, site, repo) {
     const normalizedRepo = requiredRepo('refreshBrief', site.tenantId, repo);
     const digest = await briefFromReceipts(objects, site.tenantId, normalizedRepo);

package/dist/objects/skills.d.ts

@@ -1,6 +1,6 @@
 /** Skill object: an agent-followable `instructions` body plus an optional `trigger`, evolving via supersession.
- *  `exportSkills` renders ACTIVE skills into AGENTS.md / CLAUDE.md rules; running code from a skill is deferred (security).
- *  `trigger` is stored in `trigger_text` because it is a SQLite reserved keyword. */
+ *  `skillsMarkdown` renders ACTIVE skills into AGENTS.md / CLAUDE.md rules; running code from a skill is deferred
+ *  (security). `trigger` is stored in `trigger_text` because it is a SQLite reserved keyword. */
 import type { KeysetPosition } from '../util/keyset.js';
 import type { SavableDescriptor } from './descriptor.js';
 import type { Skill, SkillStatus } from '../core/object-types.js';
@@ -35,17 +35,15 @@ export interface ListSkillsOpts {
 }
 export declare const SKILL: SavableDescriptor<'skill', SaveSkillOpts>;
 /** Create a skill, or a new version superseding an existing one, in the `objects` store group's one transaction. */
-export declare function saveSkill(hippoRoot: string, tenantId: string, opts: SaveSkillOpts, actor?: string): Skill;
+export declare function saveSkill(objects: Objects, hippoRoot: string, tenantId: string, opts: SaveSkillOpts, actor?: string): Promise<Skill>;
 /** Close (retire) an active skill; a superseded row is terminal. */
-export declare function closeSkill(hippoRoot: string, tenantId: string, id: number, actor?: string): Skill;
-export declare function loadSkillById(hippoRoot: string, tenantId: string, id: number): Skill | null;
-export declare function loadSkills(hippoRoot: string, tenantId: string, opts?: ListSkillsOpts): Skill[];
-export declare function loadActiveSkills(hippoRoot: string, tenantId: string, opts?: {
+export declare function closeSkill(objects: Objects, tenantId: string, id: number, actor?: string): Promise<Skill>;
+export declare function loadSkillById(objects: Objects, tenantId: string, id: number): Promise<Skill | null>;
+export declare function loadSkills(objects: Objects, tenantId: string, opts?: ListSkillsOpts): Promise<Skill[]>;
+export declare function loadActiveSkills(objects: Objects, tenantId: string, opts?: {
     limit?: number;
-}): Skill[];
-/** Render the tenant's ACTIVE skills into one AGENTS.md / CLAUDE.md-style markdown block (H2 per skill, ordered by skill_name) and return it; writes no file.
- *  Bounded by MAX_EXPORT_SKILLS rows; instructions are emitted verbatim. */
-export declare function exportSkills(hippoRoot: string, tenantId: string): string;
-/** `exportSkills` over a served store's group. */
+}): Promise<Skill[]>;
+/** Render the tenant's ACTIVE skills into one AGENTS.md / CLAUDE.md-style markdown block (H2 per skill, ordered by
+ *  skill_name) and return it; writes no file. Bounded by MAX_EXPORT_SKILLS rows; instructions are emitted verbatim. */
 export declare function skillsMarkdown(objects: Objects, tenantId: string): Promise<string>;
 //# sourceMappingURL=skills.d.ts.map

package/dist/objects/skills.js

@@ -1,11 +1,10 @@
 /** Skill object: an agent-followable `instructions` body plus an optional `trigger`, evolving via supersession.
- *  `exportSkills` renders ACTIVE skills into AGENTS.md / CLAUDE.md rules; running code from a skill is deferred (security).
- *  `trigger` is stored in `trigger_text` because it is a SQLite reserved keyword. */
+ *  `skillsMarkdown` renders ACTIVE skills into AGENTS.md / CLAUDE.md rules; running code from a skill is deferred
+ *  (security). `trigger` is stored in `trigger_text` because it is a SQLite reserved keyword. */
 import { BadRequestError } from '../core/api-errors.js';
 import { assertTenantId } from '../store/tenant.js';
 import { checkText, requireLine } from './fields.js';
-import { closeObjectAt, listObjectsAt, objectByIdAt, saveObjectAt } from './lifecycle.js';
-import { sqliteObjects } from '../store/sqlite/objects-group.js';
+import { closeObject, listObjects, objectById, saveObject } from './lifecycle.js';
 export const VALID_SKILL_STATES = new Set([
     'active',
     'superseded',
@@ -19,7 +18,8 @@ export const MAX_SKILL_TRIGGER_LEN = 1024;
 /** Aggregate bound on a single export render so the export body is never unbounded.
  *  Realistic active-skill counts are tens; 1000 is a generous bound. */
 export const MAX_EXPORT_SKILLS = 1000;
-/** The trigger as stored, or null for none. One line, because a newline would forge a heading inside the exported **When:** line. */
+/** The trigger as stored, or null for none. One line, because a newline would forge a heading inside the
+ *  exported **When:** line. */
 function checkTrigger(trigger) {
     if (trigger === undefined || trigger === null || trigger.trim().length === 0)
         return null;
@@ -69,29 +69,24 @@ export const SKILL = {
     },
 };
 /** Create a skill, or a new version superseding an existing one, in the `objects` store group's one transaction. */
-export function saveSkill(hippoRoot, tenantId, opts, actor = 'cli') {
-    return saveObjectAt(SKILL, { hippoRoot, tenantId, actor }, opts);
+export function saveSkill(objects, hippoRoot, tenantId, opts, actor = 'cli') {
+    return saveObject(objects, SKILL, { hippoRoot, tenantId, actor }, opts);
 }
 /** Close (retire) an active skill; a superseded row is terminal. */
-export function closeSkill(hippoRoot, tenantId, id, actor = 'cli') {
-    return closeObjectAt(hippoRoot, SKILL, tenantId, id, actor);
+export function closeSkill(objects, tenantId, id, actor = 'cli') {
+    return closeObject(objects, SKILL, tenantId, id, actor);
 }
-export function loadSkillById(hippoRoot, tenantId, id) {
-    return objectByIdAt(hippoRoot, SKILL, tenantId, id);
+export function loadSkillById(objects, tenantId, id) {
+    return objectById(objects, SKILL, tenantId, id);
 }
-export function loadSkills(hippoRoot, tenantId, opts = {}) {
-    return listObjectsAt(hippoRoot, SKILL, tenantId, opts);
+export function loadSkills(objects, tenantId, opts = {}) {
+    return listObjects(objects, SKILL, tenantId, opts);
 }
-export function loadActiveSkills(hippoRoot, tenantId, opts = {}) {
-    return loadSkills(hippoRoot, tenantId, { status: 'active', limit: opts.limit });
+export function loadActiveSkills(objects, tenantId, opts = {}) {
+    return loadSkills(objects, tenantId, { status: 'active', limit: opts.limit });
 }
-/** Render the tenant's ACTIVE skills into one AGENTS.md / CLAUDE.md-style markdown block (H2 per skill, ordered by skill_name) and return it; writes no file.
- *  Bounded by MAX_EXPORT_SKILLS rows; instructions are emitted verbatim. */
-export function exportSkills(hippoRoot, tenantId) {
-    assertTenantId('exportSkills', tenantId);
-    return skillsBlock(sqliteObjects(hippoRoot).activeSkillsByName(tenantId, MAX_EXPORT_SKILLS));
-}
-/** `exportSkills` over a served store's group. */
+/** Render the tenant's ACTIVE skills into one AGENTS.md / CLAUDE.md-style markdown block (H2 per skill, ordered by
+ *  skill_name) and return it; writes no file. Bounded by MAX_EXPORT_SKILLS rows; instructions are emitted verbatim. */
 export async function skillsMarkdown(objects, tenantId) {
     assertTenantId('exportSkills', tenantId);
     return skillsBlock(await objects.activeSkillsByName(tenantId, MAX_EXPORT_SKILLS));

package/dist/postinstall.js

@@ -4,18 +4,20 @@ import * as os from 'node:os';
 import * as path from 'node:path';
 import { detectRealCodexPath, isCodexWrapperInstalled, repairCodexWrapperIfInstalled } from './hooks/codex-wrapper.js';
 import { claudeConfigDir } from './util/agent-homes.js';
-import { errorMessage, log } from './util/log.js';
+import { errorFields, errorMessage, log } from './util/log.js';
 function main() {
     if (envSkipPostinstall())
         return;
     try {
-        // Repair-only, for users who opted in (a Codex update can restore the real binary over our shim): swapping the binary from postinstall
-        // is a consent violation that supply-chain scanners read as hijacking, so first install is `hippo hook install codex` only.
+        // Repair-only, for users who opted in (a Codex update can restore the real binary over our shim): swapping the
+        // binary from postinstall
+        // is a consent violation that supply-chain scanners read as hijacking, so first install is `hippo hook install
+        // codex` only.
         repairCodexWrapperIfInstalled();
     }
     catch (err) {
         // Never fail package install because auto-integration could not be applied.
-        log.debug(`postinstall: codex wrapper not repaired: ${errorMessage(err)}`);
+        log.warn(`postinstall: codex wrapper not repaired: ${errorMessage(err)}`, errorFields(err));
     }
     try {
         printClaudeCodeNudge();
@@ -30,8 +32,12 @@ function main() {
         // Never fail package install because the install hint could not be printed.
     }
 }
-/** Read-only nudge: if Claude Code is detected and the Hippo UserPromptSubmit hook is not installed, point the user at `hippo init`.
- * It never patches ~/.claude/settings.json from a package postinstall: surprising, against least authority, and trips security scanners. */
+/**
+ * Read-only nudge: if Claude Code is detected and the Hippo UserPromptSubmit hook is not installed, point the user at
+ * `hippo init`.
+ * It never patches ~/.claude/settings.json from a package postinstall: surprising, against least authority, and trips
+ * security scanners.
+ */
 function printClaudeCodeNudge() {
     const claudeDir = claudeConfigDir(os.homedir());
     if (!fs.existsSync(claudeDir))
@@ -67,7 +73,9 @@ function printClaudeCodeNudge() {
     line('To skip this message on future installs: export HIPPO_SKIP_POSTINSTALL=1');
     line('');
 }
-/** Read-only nudge: if the Codex CLI is on PATH and the session-capture wrapper is not installed, print the opt-in command;
+/**
+ * Read-only nudge: if the Codex CLI is on PATH and the session-capture wrapper is not installed, print the opt-in
+ * command;
  * same least-authority reasoning as the Claude Code nudge, we never swap the user's binary. */
 function printCodexNudge() {
     if (isCodexWrapperInstalled())

package/dist/predictions/planning-fallacy.d.ts

@@ -1,7 +1,9 @@
 import type { AppendAuditOpts } from '../store/audit.js';
 import { type ForwardClaimMatch } from '../learn/forward-claim-detector.js';
 import type { PlanningFallacyEvidence } from '../store/planning-fallacy-evidence.js';
-/** Surface delivered on `RecallResult.planningFallacyHint` when a recall query carries a forward-prediction phrase and the closest class has closed history,
+/**
+ * Surface delivered on `RecallResult.planningFallacyHint` when a recall query carries a forward-prediction phrase and
+ * the closest class has closed history,
  *  so the agent sees its own track record at the moment of forecasting. */
 export interface PlanningFallacyHint {
     classTag: string;
@@ -10,25 +12,36 @@ export interface PlanningFallacyHint {
     baserateSummary: string;
     /** Discriminator vs hypothetical future manual-override hints. */
     source: 'j3.2-auto';
-    /** The regex match snippet that triggered detection, so the agent sees WHY the hint appeared and can self-correct if detection misfired. */
+    /**
+     * The regex match snippet that triggered detection, so the agent sees WHY the hint appeared and can self-correct if
+     * detection misfired.
+     */
     detectedPhrase: string;
     nClosed: number;
     /** Null only when every closed-row had estimate_value=0 (ratio undefined). */
     meanRatio: number | null;
 }
-/** "Watching" variant emitted when the forward-claim regex matched but no baserate hint was returned (no prediction class tag overlaps the query's tokens).
- *  It surfaces the detection plus a one-line suggestion so the agent can re-tag the prediction or pass the suggestion to the user. */
+/**
+ * "Watching" variant emitted when the forward-claim regex matched but no baserate hint was returned (no prediction
+ * class tag overlaps the query's tokens).
+ * It surfaces the detection plus a one-line suggestion so the agent can re-tag the prediction or pass the suggestion to
+ * the user.
+ */
 export interface PlanningFallacyWatching {
     /** The forward-claim phrase the detector matched (verbatim regex match snippet). */
     detectedPhrase: string;
-    /** Why hippo could not produce a baserate hint despite the match: 'no_class_match' (no class scored >=1 on token overlap)
+    /**
+     * Why hippo could not produce a baserate hint despite the match: 'no_class_match' (no class scored >=1 on token
+     * overlap)
      *  or 'tiebreak' (>=2 classes tied at the best score; silent on ambiguity). */
     reason: 'no_class_match' | 'tiebreak';
     /** One-line agent-facing suggestion for how the user can give hippo
      *  enough signal to produce a baserate next time. */
     suggestion: string;
 }
-/** What `decidePlanningFallacy` hands to recall: EITHER `hint` (baserate available) OR `watching` (regex fired, no baserate), or NEITHER (mode=off,
+/**
+ * What `decidePlanningFallacy` hands to recall: EITHER `hint` (baserate available) OR `watching` (regex fired, no
+ * baserate), or NEITHER (mode=off,
  *  no queryText, no regex match, or nClosed=0). Never both. */
 export interface PlanningFallacyOutput {
     hint?: PlanningFallacyHint;

package/dist/predictions/planning-fallacy.js

@@ -3,7 +3,8 @@ import { detectForwardClaim } from '../learn/forward-claim-detector.js';
 const TARGET_ID_CHARS = 100;
 /** The forward claim in a recall query; null when HIPPO_AUTODEBIAS=off, the query is empty or no claim matches. */
 export function detectPlanningClaim(queryText, opts = {}) {
-    // Env read FIRST so AUTODEBIAS=off pays zero regex cost; read per call so tests can toggle it without a module reload.
+    // Env read FIRST so AUTODEBIAS=off pays zero regex cost; read per call so tests can toggle it without a module
+    // reload.
     const mode = opts.mode ?? (envAutodebiasOff() ? 'off' : 'regex');
     if (mode === 'off')
         return null;
@@ -52,7 +53,8 @@ export function decidePlanningFallacy(match, evidence, tenantId, actor) {
     };
 }
 const TIEBREAK_SUGGESTION = 'Multiple prediction classes tied on this query. Refine the query or rename overlapping classes to break the tie.';
-const NO_CLASS_MATCH_SUGGESTION = 'No matching prediction class for this forward-claim. Tag your prediction with `hippo predict --class <name>` to start tracking this class.';
+const NO_CLASS_MATCH_SUGGESTION = 'No matching prediction class for this forward-claim. Tag your prediction with `hippo predict --class <name>` to ' +
+    'start tracking this class.';
 function watchingWithAudit(tenantId, actor, match, reason, suggestion) {
     return {
         output: {

package/dist/rerankers/clef.d.ts

@@ -17,9 +17,15 @@ interface ClefScores {
 }
 /** Transport from trusted local env, never call arguments: HIPPO_CLEF_ENDPOINT wins over hosted Workers AI. */
 export declare function resolveClefRoute(model: ClefModel): ClefRoute;
-/** Unwraps a Workers AI `{ result }` envelope or a bare System One reply and checks model and `c1..cN`; a string is the rejection reason. */
+/**
+ * Unwraps a Workers AI `{ result }` envelope or a bare System One reply and checks model and `c1..cN`; a string is the
+ * rejection reason.
+ */
 export declare function parseClefReply(body: JsonValue, n: number, model: ClefModel, requireModel: boolean): ClefScores | string;
-/** A CLEF reranker for one model: Jev's request shape and pool; any failure keeps the native order (never paid Jev) and warns. */
+/**
+ * A CLEF reranker for one model: Jev's request shape and pool; any failure keeps the native order (never paid Jev) and
+ * warns.
+ */
 export declare function createClefReranker(model: ClefModel): RerankerFn;
 export {};
 //# sourceMappingURL=clef.d.ts.map

package/dist/rerankers/clef.js

@@ -1,10 +1,11 @@
-import { envClefEndpoint, envClefEndpointToken, envClefTimeoutMs, envCloudflareAccountId, envCloudflareApiToken } from '../util/env.js';
+import { envClefEndpoint, envClefEndpointToken, envClefTimeoutMs, envCloudflareAccountId, envCloudflareApiToken, } from '../util/env.js';
 import { buildRelevanceRequest, JEV_DEFAULT_TOP_K, rankByScores } from './jev.js';
 import { createOutageWarning } from './outage-warning.js';
 import { rerankerPost, RERANKER_MAX_REPLY_BYTES } from './remote.js';
 import { readCappedJson } from '../util/capped-json.js';
 import { isJsonObject, isJsonString } from '../util/json.js';
 import { errorMessage } from '../util/log.js';
+import { isLoopbackHost } from '../util/net.js';
 const RAY_ID_MAX_CHARS = 64;
 const CLEF_MODELS = ['clef-flash', 'clef'];
 const DEFAULT_TIMEOUT_MS = 15_000;
@@ -16,10 +17,6 @@ const ACCOUNT_ID = /^[0-9a-f]{32}$/i;
 export function isClefModel(name) {
     return CLEF_MODELS.some((m) => m === name);
 }
-// Plain http would put the token and the memory text on the wire, so only the local machine may use it.
-function isLoopback(hostname) {
-    return hostname === 'localhost' || hostname === '[::1]' || /^127(\.\d{1,3}){3}$/.test(hostname);
-}
 function isNumber(v) {
     return Number.isFinite(v);
 }
@@ -49,7 +46,8 @@ export function resolveClefRoute(model) {
         if (parsed.username || parsed.password) {
             throw new Error('HIPPO_CLEF_ENDPOINT must not embed credentials; set HIPPO_CLEF_ENDPOINT_TOKEN');
         }
-        if (parsed.protocol === 'http:' && !isLoopback(parsed.hostname)) {
+        // Plain http would put the token and the memory text on the wire, so only the local machine may use it.
+        if (parsed.protocol === 'http:' && !isLoopbackHost(parsed.hostname)) {
             throw new Error('HIPPO_CLEF_ENDPOINT must use https unless it is on this machine');
         }
         const endpointToken = envClefEndpointToken();
@@ -70,7 +68,10 @@ export function resolveClefRoute(model) {
         backend: 'cloudflare',
     };
 }
-/** Unwraps a Workers AI `{ result }` envelope or a bare System One reply and checks model and `c1..cN`; a string is the rejection reason. */
+/**
+ * Unwraps a Workers AI `{ result }` envelope or a bare System One reply and checks model and `c1..cN`; a string is the
+ * rejection reason.
+ */
 export function parseClefReply(body, n, model, requireModel) {
     if (!isJsonObject(body))
         return 'reply is not a JSON object';
@@ -80,8 +81,9 @@ export function parseClefReply(body, n, model, requireModel) {
     if (!isJsonObject(reply))
         return 'reply has no result object';
     const actual = reply.model;
-    if (actual !== undefined && (!isJsonString(actual) || actual.trim() !== model))
+    if (actual !== undefined && (!isJsonString(actual) || actual.trim() !== model)) {
         return 'reply names a different model';
+    }
     if (actual === undefined && requireModel)
         return 'reply does not name its model';
     const answers = reply.answers;
@@ -139,7 +141,10 @@ function nativeOrder(head, provenance) {
         rerankProvenance: { ...provenance },
     }));
 }
-/** A CLEF reranker for one model: Jev's request shape and pool; any failure keeps the native order (never paid Jev) and warns. */
+/**
+ * A CLEF reranker for one model: Jev's request shape and pool; any failure keeps the native order (never paid Jev) and
+ * warns.
+ */
 export function createClefReranker(model) {
     const outage = createOutageWarning(model, 'keeping the native order');
     return async (query, results, options) => {

package/dist/rerankers/cross-encoder.d.ts

@@ -27,7 +27,8 @@ type ImportModule = () => Promise<{
     readonly name: string;
     readonly mod: TransformersModuleNamespace;
 } | null>;
-/** Track 2 reranker: MS-MARCO MiniLM cross-encoder, identity fallback if the model will not load. Each instance owns its model and outage warning. */
+/** Track 2 reranker: MS-MARCO MiniLM cross-encoder, identity fallback if the model will not load. Each instance owns
+ * its model and outage warning. */
 export declare function createCrossEncoderReranker(importModule?: ImportModule): RerankerFn;
 export {};
 //# sourceMappingURL=cross-encoder.d.ts.map

package/dist/rerankers/cross-encoder.js

@@ -15,8 +15,8 @@ async function importModelClasses(importModule) {
         throw new Error(`${name} exports no AutoTokenizer or AutoModelForSequenceClassification`);
     return { AutoTokenizer: tok, AutoModelForSequenceClassification: seq };
 }
-// NOT the text-classification pipeline: this is a num_labels=1 regression head and that pipeline softmaxes a length-1 logit vector (always 1.0).
-// Read the logit, then squash it.
+// NOT the text-classification pipeline: this is a num_labels=1 regression head and that pipeline softmaxes a length-1
+// logit vector (always 1.0). Read the logit, then squash it.
 async function buildPipeline(importModule) {
     const mod = await importModelClasses(importModule);
     const [tokenizer, model] = await Promise.all([
@@ -56,8 +56,9 @@ async function scoreHead(pipe, query, head) {
             succeeded++;
         }
         catch (err) {
-            // One bad inference must not sink the whole pass.
-            log.debug(`cross-encoder inference failed, keeping the base score: ${errorMessage(err)}`);
+            // One bad inference must not sink the whole pass; a pass where every call fails is warned about by the outage
+            // tracker below.
+            log.debug(`cross-encoder inference failed, keeping the base score: ${errorMessage(err)}`, errorFields(err));
             ceScore = r.score;
         }
         return {
@@ -73,7 +74,8 @@ async function scoreHead(pipe, query, head) {
     scored.forEach((r, i) => (r.postRerankRank = i + 1));
     return { results: scored, succeeded };
 }
-/** Track 2 reranker: MS-MARCO MiniLM cross-encoder, identity fallback if the model will not load. Each instance owns its model and outage warning. */
+/** Track 2 reranker: MS-MARCO MiniLM cross-encoder, identity fallback if the model will not load. Each instance owns
+ * its model and outage warning. */
 export function createCrossEncoderReranker(importModule = importTransformers) {
     const outage = createOutageWarning('cross-encoder', 'falling back to identity ordering');
     // The outage warning already says each failure, at most once per window, so the loads report nothing themselves.
@@ -82,7 +84,8 @@ export function createCrossEncoderReranker(importModule = importTransformers) {
         const head = results.slice(0, options?.topK ?? DEFAULT_CROSS_ENCODER_TOP_K);
         let pipe;
         try {
-            // One shared load per backoff window: two first calls fetch the model once, and a failure is not fetched again on every recall.
+            // One shared load per backoff window: two first calls fetch the model once, and a failure is not fetched again on
+            // every recall.
             pipe = await pipelines.load(MODEL_NAME, () => buildPipeline(importModule));
         }
         catch (err) {

package/dist/rerankers/index.js

@@ -2,7 +2,8 @@ import { createClefReranker } from './clef.js';
 import { createCrossEncoderReranker } from './cross-encoder.js';
 import { createJevReranker } from './jev.js';
 import { createLlmReranker } from './llm.js';
-// Each reranker is built once here, so its outage warning lasts the process; jev falls back to the same cross-encoder, so one model loads.
+// Each reranker is built once here, so its outage warning lasts the process; jev falls back to the same cross-encoder,
+// so one model loads.
 const crossEncoder = createCrossEncoderReranker();
 const REGISTRY = {
     clef: createClefReranker('clef'),

package/dist/rerankers/jev.js

@@ -39,7 +39,8 @@ function parseScores(body, n) {
 export function buildRelevanceRequest(query, head) {
     // Strict: this text leaves the machine, so Bearer, Basic-auth and JWT shapes go too.
     const lines = head.map((r, i) => `[${i + 1}] ${truncateWithEllipsis(redactSecretsStrict(r.entry.content), TRUNCATE_CHARS)}`);
-    const state = `Query: ${redactSecretsStrict(query)}\n\nNumbered candidate memories from an AI coding agent's project store:\n\n${lines.join('\n\n')}`;
+    const state = `Query: ${redactSecretsStrict(query)}\n\nNumbered candidate memories from an AI coding agent's ` +
+        `project store:\n\n${lines.join('\n\n')}`;
     const questions = {};
     for (let i = 1; i <= head.length; i++) {
         questions[`c${i}`] = {

package/dist/rerankers/llm.d.ts

@@ -1,5 +1,9 @@
 import type { RerankerFn } from './types.js';
-/** Track 3 reranker (skeleton): listwise LLM rerank on a customer-supplied OpenAI-compatible endpoint, gated on HIPPO_LLM_RERANKER_URL against accidental cost.
- * Timeout is 30s for the whole call, retries included (HIPPO_LLM_RERANKER_TIMEOUT_MS); any failure falls back to identity ordering, so recall never hangs. */
+/**
+ * Track 3 reranker (skeleton): listwise LLM rerank on a customer-supplied OpenAI-compatible endpoint, gated on
+ * HIPPO_LLM_RERANKER_URL against accidental cost.
+ * Timeout is 30s for the whole call, retries included (HIPPO_LLM_RERANKER_TIMEOUT_MS); any failure falls back to
+ * identity ordering, so recall never hangs.
+ */
 export declare function createLlmReranker(): RerankerFn;
 //# sourceMappingURL=llm.d.ts.map

package/dist/rerankers/llm.js

@@ -7,8 +7,12 @@ import { isJsonObject, isJsonString } from '../util/json.js';
 import { errorMessage } from '../util/log.js';
 const DEFAULT_LLM_RERANK_TOP_K = 20;
 const DEFAULT_TIMEOUT_MS = 30_000;
-/** Track 3 reranker (skeleton): listwise LLM rerank on a customer-supplied OpenAI-compatible endpoint, gated on HIPPO_LLM_RERANKER_URL against accidental cost.
- * Timeout is 30s for the whole call, retries included (HIPPO_LLM_RERANKER_TIMEOUT_MS); any failure falls back to identity ordering, so recall never hangs. */
+/**
+ * Track 3 reranker (skeleton): listwise LLM rerank on a customer-supplied OpenAI-compatible endpoint, gated on
+ * HIPPO_LLM_RERANKER_URL against accidental cost.
+ * Timeout is 30s for the whole call, retries included (HIPPO_LLM_RERANKER_TIMEOUT_MS); any failure falls back to
+ * identity ordering, so recall never hangs.
+ */
 export function createLlmReranker() {
     const outage = createOutageWarning('llm', 'keeping the input order');
     return async (query, results, options) => {
@@ -47,7 +51,8 @@ function replyText(body) {
 async function requestPermutation(url, query, head) {
     const key = envLlmRerankerKey();
     const prompt = [
-        `Rerank the candidates below by relevance to the query. Output a JSON array of indices (zero-indexed) in best-first order.`,
+        `Rerank the candidates below by relevance to the query. Output a JSON array of indices (zero-indexed) in ` +
+            `best-first order.`,
         `Query: ${redactSecretsStrict(query)}`,
         ...head.map((r, i) => `[${i}] ${redactSecretsStrict(r.entry.content)}`),
         `Output format: [<int>, <int>, ...] with all ${head.length} indices.`,

package/dist/rerankers/remote.d.ts

@@ -1,4 +1,6 @@
 export declare const RERANKER_MAX_REPLY_BYTES: number;
-/** POST a scoring request. A dropped connection, 429 or 5xx is retried, since scoring changes nothing on the far side. */
+/**
+ * POST a scoring request. A dropped connection, 429 or 5xx is retried, since scoring changes nothing on the far side.
+ */
 export declare function rerankerPost(url: string, init: RequestInit, budgetMs: number): Promise<Response>;
 //# sourceMappingURL=remote.d.ts.map