@gamaze/hicortex 0.20.7 → 0.20.9

package/dist/relink.js

@@ -134,7 +134,6 @@ async function runRelink(options = {}) {
             `This machine is a client of ${config.serverUrl ?? "a remote server"} — run relink on the server.`);
     }
     // Classification is heuristic-only — no LLM client, no budget cap.
-    const budget = new consolidate_js_1.BudgetTracker(Number.MAX_SAFE_INTEGER);
     const dbPath = (0, db_js_1.resolveDbPath)(options.dbPath);
     const db = (0, db_js_1.initDb)(dbPath);
     const report = {
@@ -215,9 +214,9 @@ async function runRelink(options = {}) {
             report.skippedExisting += batchSkippedExisting;
             report.skippedDuplicate += batchSkippedDuplicate;
             // Phase B: classification — shared heuristic-only path (LLM retired).
-            // classifyLinkCandidates ignores the null LLM/budget and returns each
-            // candidate's heuristic type (extends/relates_to).
-            const classified = await (0, consolidate_js_1.classifyLinkCandidates)(candidates, null, budget);
+            // classifyLinkCandidates returns each candidate's heuristic type
+            // (extends/relates_to); #405 dropped its dead llm/budget params.
+            const classified = await (0, consolidate_js_1.classifyLinkCandidates)(candidates);
             const types = classified.types;
             report.llmClassified += classified.llmClassified; // always 0
             report.heuristicFallback += classified.heuristicFallback;

package/dist/retrieval.d.ts

@@ -2,14 +2,15 @@
  * Retrieval layer with composite scoring, RRF fusion, and graph traversal.
  * Ported from hicortex/retrieval.py — same scoring model and weights.
  *
- * Scoring model (weights are config-driven since 0.15.2 — see configureScoring):
+ * Scoring model (weights are RELEASE-MANAGED since #408 — calibration.ts;
+ * configureScoring is the eval/test seam only):
  *   score = similarity * 0.50 + effective_strength * 0.20
  *         + connection_score * 0.15 + recency * 0.15
  *         + fresh-memory bonus (≤ 0.15, linear over the first 7 days)
  *         then × 0.50 if the memory was superseded by a later decision
  *
  * Decay model (B+E+D):
- *   base_decay = derived from decayHalfLifeDays (config; default 365 → ~1-year
+ *   base_decay = derived from the calibration half-life (365 → ~1-year
  *                half-life at importance 0.5, importance-scaled either way)
  *   decay_rate = 1 - base_decay * (1 - importance)
  *   decay_rate = 1 - (1 - decay_rate) * 0.7^access_count
@@ -19,10 +20,8 @@
  */
 import type Database from "better-sqlite3";
 import type { Memory, MemorySearchResult } from "./types.js";
-/** Default decay half-life (days) at importance 0.5. #192: was 0.0005/h
- *  (~115-day half-life at base 0.5) — aggressive enough to bury the long tail
- *  in ranking. Long-term remembering is the product; time preference stays,
- *  but mild. */
+/** Default decay half-life (days) at importance 0.5 — release-managed
+ *  (#408): the constant lives in calibration.ts with its provenance. */
 export declare const DEFAULT_DECAY_HALF_LIFE_DAYS = 365;
 /**
  * Derive the per-hour base decay constant from a half-life target: for the
@@ -33,26 +32,26 @@ export declare const DEFAULT_DECAY_HALF_LIFE_DAYS = 365;
  */
 export declare function decayConstantForHalfLife(days: number): number;
 /**
- * Configure the decay speed from config (`decayHalfLifeDays`). Called at boot
- * by the server and the nightly so both processes score with the same clock.
- * Invalid/absent values keep the default. Exported value for tests.
+ * Configure the decay speed for THIS process (the eval/test seam — #408).
+ * Production NEVER passes an argument: every process scores with the
+ * calibration half-life (calibration.ts DECAY_HALF_LIFE_DAYS). An
+ * invalid/absent value keeps the default. Exported value for tests.
  */
-export declare function configureDecay(options?: {
-    halfLifeDays?: unknown;
-}): number;
-interface RecallDefaults {
+export declare function configureDecay(halfLifeDays?: number): number;
+export interface RecallDefaults {
     searchLimit: number;
     recentLimit: number;
     recentWindowDays: number;
     coldExposureSlots: number;
 }
 /**
- * Configure recall breadth from config. Called at boot next to
- * configureDecay(); invalid/absent values keep the shipped defaults.
- * Returns the resolved values (for logging + tests).
+ * Configure recall breadth from RESOLVED overrides (the eval/test seam —
+ * #408). Production calls this with no argument: the calibration defaults
+ * (calibration.ts) apply. Invalid/absent values keep the shipped default per
+ * key. Returns the resolved values (for logging + tests).
  */
-export declare function configureRecall(config?: Record<string, unknown> | null): RecallDefaults;
-interface ScoringWeights {
+export declare function configureRecall(overrides?: Partial<RecallDefaults> | null): RecallDefaults;
+export interface ScoringWeights {
     similarity: number;
     strength: number;
     connections: number;
@@ -74,29 +73,28 @@ interface ScoringWeights {
     rrfVectorWeight: number;
 }
 /**
- * Configure scoring weights + ranking knobs from config. Called at boot by the
- * server and the nightly (alongside configureDecay/configureRecall) so
- * retrieval and consolidation rank identically. Invalid/absent values keep the
- * shipped default per key. Returns the resolved set for logging/tests. Also
- * pushes the #205 BM25F field weights into storage (storage.configureBm25Fts)
- * so searchFts ranks with the same config — BM25F weights live in storage.ts
- * (next to the FTS column declaration they mirror) but are read here from the
- * SAME config object for one-place tuning.
+ * Configure scoring weights + ranking knobs from RESOLVED overrides (the
+ * eval/test seam — #408). Production calls this with no argument: the
+ * calibration defaults (calibration.ts) apply, identically in the daemon and
+ * the nightly. Invalid/absent values keep the shipped default per key.
+ * Returns the resolved set for logging/tests. (The #205 BM25F field weights
+ * are NOT touched here — they live in storage.ts and resolve from the same
+ * calibration module via storage.configureBm25Fts.)
  */
-export declare function configureScoring(config?: Record<string, unknown> | null): ScoringWeights;
+export declare function configureScoring(overrides?: Partial<ScoringWeights> | null): ScoringWeights;
 /** Current resolved weights (tests + status output). */
 export declare function getScoringWeights(): ScoringWeights;
 /** EMA rate for the session-intent centroid: centroid_new = (1-α)·old + α·prompt. */
 export declare const SESSION_INTENT_ALPHA = 0.4;
 /**
- * Configure session-intent keying from config. Called at server boot next to
- * configureScoring (the nightly does no recall, so it does not need this).
- * Reads only `sessionIntentWeight` ([0,1]; 0 = disabled). Invalid/out-of-range
- * values keep the shipped default. Returns `{ weight, alpha }` — alpha is the
- * fixed constant, surfaced so the recall closure passes it to the registry in
- * one call.
+ * Configure session-intent keying for THIS process (the eval/test seam —
+ * #408). Production calls this with no argument: the calibration weight
+ * (calibration.ts SESSION_INTENT_WEIGHT) applies. `weight` is [0,1] (0 =
+ * disabled — the eval kill-switch); invalid/out-of-range values keep the
+ * shipped default. Returns `{ weight, alpha }` — alpha is the fixed constant,
+ * surfaced so the recall closure passes it to the registry in one call.
  */
-export declare function configureSessionIntent(config?: Record<string, unknown> | null): {
+export declare function configureSessionIntent(weight?: number): {
     weight: number;
     alpha: number;
 };
@@ -161,6 +159,32 @@ export declare function findSupersededIds(db: Database.Database, candidateIds: s
  * (NULL status, no link) — they never match either arm.
  */
 export declare function findDemotedIds(db: Database.Database, candidateIds: string[]): Set<string>;
+/**
+ * Hop cap for the belief walk (#393 D). Supersession edges advance
+ * created_at monotonically (the stage only links old → new), so chains are
+ * acyclic by construction and 10 hops is far beyond any real revision depth;
+ * the cap is cheap insurance (see beliefWalkTerminal for why it is needed
+ * anyway).
+ */
+export declare const BELIEF_WALK_MAX_HOPS = 10;
+/**
+ * Terminal of the supersession chain starting at `id` (#393 D): follow
+ * superseded_by edges transitively until a memory with no outgoing edge and
+ * return it — `id` itself when there is nothing to walk, or whichever node
+ * the walk stopped on when it aborts. Shared by retrieval (the belief-walk
+ * splice in retrieve()/searchRecent()) and the eval harness (the
+ * planted-pairs version_chain class probe), so both agree on what "the
+ * chain's current truth" is.
+ *
+ * Edges advance created_at monotonically (acyclic by construction), BUT
+ * applyExplicitMark does no age check and created_at is backdatable from
+ * session_date — so a cycle or an absurdly long chain is not impossible.
+ * The visited set (seeded with `id`) and the BELIEF_WALK_MAX_HOPS cap are
+ * cheap insurance against exactly that; the supersededDemotion multiplier
+ * in computeScore remains the safety net for rows the walk does not fully
+ * resolve (no edge, cycle, cap abort, absorbed terminal).
+ */
+export declare function beliefWalkTerminal(db: Database.Database, id: string, maxHops?: number): string;
 /**
  * Convert an L2 distance (as returned by sqlite-vec's vec0 `distance`) to
  * cosine similarity. Valid because our embeddings are L2-normalized
@@ -171,6 +195,16 @@ export declare function findDemotedIds(db: Database.Database, candidateIds: stri
  * by consolidate.ts so pre-#145 importers keep working.
  */
 export declare function l2ToCosine(distance: number): number;
+/**
+ * Cosine similarity between two stored embeddings (#393 increment B). The
+ * similarity source measures cosines transitively via vec0 L2 distances; the
+ * scout source finds its candidates through FTS (no vec0 query), so it
+ * measures the pair cosine directly from the stored vectors instead —
+ * valid because every embedding we store is L2-normalized (embedder.ts).
+ * Used as link strength / a ranker, never as a gate (the scout has no
+ * similarity floor — that is the point of the increment).
+ */
+export declare function cosineBetweenVectors(a: Float32Array, b: Float32Array): number;
 /**
  * Compute decayed strength with adaptive decay (B+E+D model).
  * Exported for use by consolidation decay/prune stage.
@@ -264,4 +298,3 @@ export declare function searchRecent(db: Database.Database, options?: {
     project?: string | null;
     limit?: number;
 }): MemorySearchResult[];
-export {};