recallnest 1.4.1 → 2.2.1

package/src/narrative-schema.ts

@@ -0,0 +1,79 @@
+/**
+ * Autobiographical Narrative Architecture — orthogonal metadata layer.
+ *
+ * Adds a three-level narrative hierarchy (life-period / general-event / specific-event)
+ * on top of the existing 6 durable memory categories. This enables temporal grouping
+ * and narrative retrieval without disrupting category logic.
+ *
+ * Philosophy: Conway's theory of autobiographical memory — memories organize
+ * hierarchically from life themes → general events → specific episodes.
+ *
+ * Feature flag: RECALLNEST_NARRATIVE_MODE=true
+ */
+
+import { z } from "zod";
+
+// ---------------------------------------------------------------------------
+// Feature Flag
+// ---------------------------------------------------------------------------
+
+export function isNarrativeModeEnabled(): boolean {
+  return process.env.RECALLNEST_NARRATIVE_MODE === "true";
+}
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+export interface NarrativeMetadata {
+  /** Life period identifier (auto-generated from scope prefix + quarterly time window) */
+  lifePeriodId: string;
+  /** Human-readable label for the life period */
+  lifePeriodLabel: string;
+  /** General event identifier (groups related memories within a day/session) */
+  generalEventId: string;
+  /** Human-readable label for the general event */
+  generalEventLabel: string;
+  /** Specific event identifier (unique episode) */
+  specificEventId: string;
+  /** Human-readable label for the specific event */
+  specificEventLabel: string;
+  /** Event start timestamp (epoch ms) */
+  startAt: number;
+  /** Event end timestamp (epoch ms, null if ongoing) */
+  endAt: number | null;
+  /** Sequence number within the general event for ordering */
+  sequence: number;
+}
+
+// ---------------------------------------------------------------------------
+// Zod Schema
+// ---------------------------------------------------------------------------
+
+export const NarrativeMetadataSchema = z.object({
+  lifePeriodId: z.string().min(1).max(120),
+  lifePeriodLabel: z.string().min(1).max(120),
+  generalEventId: z.string().min(1).max(120),
+  generalEventLabel: z.string().min(1).max(200),
+  specificEventId: z.string().min(1).max(120),
+  specificEventLabel: z.string().min(1).max(200),
+  startAt: z.number(),
+  endAt: z.number().nullable(),
+  sequence: z.number().int().min(0),
+});
+
+// ---------------------------------------------------------------------------
+// Parser
+// ---------------------------------------------------------------------------
+
+/** Parse narrative metadata from metadata JSON string, returns null if absent */
+export function parseNarrative(metadata: string | undefined): NarrativeMetadata | null {
+  if (!metadata) return null;
+  try {
+    const parsed = JSON.parse(metadata);
+    if (parsed.narrative && typeof parsed.narrative.lifePeriodId === "string") {
+      return NarrativeMetadataSchema.parse(parsed.narrative);
+    }
+  } catch { /* malformed metadata — safe to ignore */ }
+  return null;
+}

package/src/narrative-tagger.ts

@@ -0,0 +1,164 @@
+/**
+ * Rule-based Narrative Tagger — assigns autobiographical narrative metadata.
+ *
+ * Heuristics:
+ * 1. Life period = scope prefix + quarterly time window (Conway's lifetime periods)
+ * 2. General event = scope + daily cluster OR session ID (extended events)
+ * 3. Specific event = unique episode (scope + timestamp + text hash)
+ * 4. Keyword signals enrich labels (project-setup, debugging, learning, etc.)
+ *
+ * Zero LLM cost — pure rule-based, matching the emotion-detector pattern.
+ */
+
+import type { NarrativeMetadata } from "./narrative-schema.js";
+import { isNarrativeModeEnabled } from "./narrative-schema.js";
+
+// ---------------------------------------------------------------------------
+// Keyword Signals — enrich general event labels
+// ---------------------------------------------------------------------------
+
+const EVENT_KEYWORDS: ReadonlyArray<readonly [string, readonly string[]]> = [
+  ["project-setup", ["init", "setup", "bootstrap", "create", "scaffold", "new project", "初始化", "搭建"]],
+  ["development", ["implement", "build", "code", "feature", "refactor", "开发", "实现", "重构"]],
+  ["debugging", ["debug", "bug", "fix", "error", "crash", "investigate", "调试", "排查", "修复"]],
+  ["deployment", ["deploy", "ship", "release", "publish", "launch", "上线", "部署", "发布"]],
+  ["learning", ["learn", "study", "research", "explore", "understand", "学习", "研究", "探索"]],
+  ["migration", ["migrate", "upgrade", "move", "transfer", "port", "迁移", "升级"]],
+  ["review", ["review", "audit", "inspect", "check", "评审", "审查"]],
+  ["writing", ["write", "draft", "article", "blog", "post", "写作", "文章", "草稿"]],
+] as const;
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function getQuarterLabel(date: Date): string {
+  const q = Math.floor(date.getMonth() / 3) + 1;
+  return `${date.getFullYear()}-Q${q}`;
+}
+
+function extractScopePrefix(scope: string): string {
+  return scope.split(":")[0] || "global";
+}
+
+/** Deterministic short hash for stable IDs */
+function quickHash(str: string): string {
+  let hash = 0;
+  for (let i = 0; i < str.length; i++) {
+    const char = str.charCodeAt(i);
+    hash = ((hash << 5) - hash + char) | 0;
+  }
+  return Math.abs(hash).toString(36);
+}
+
+/** Detect the dominant event type from text via keyword matching */
+function detectEventType(text: string): string | null {
+  const lower = text.toLowerCase();
+  for (const [label, keywords] of EVENT_KEYWORDS) {
+    if (keywords.some(kw => lower.includes(kw))) {
+      return label;
+    }
+  }
+  return null;
+}
+
+// ---------------------------------------------------------------------------
+// ID Derivation
+// ---------------------------------------------------------------------------
+
+function deriveLifePeriodId(scope: string, timestamp: number): string {
+  const date = new Date(timestamp);
+  const quarter = getQuarterLabel(date);
+  const prefix = extractScopePrefix(scope);
+  return `lp:${prefix}:${quarter}`;
+}
+
+function deriveLifePeriodLabel(scope: string, timestamp: number): string {
+  const date = new Date(timestamp);
+  const quarter = getQuarterLabel(date);
+  const prefix = extractScopePrefix(scope);
+  return `${prefix} (${quarter})`;
+}
+
+function deriveGeneralEventId(scope: string, timestamp: number, sessionId?: string): string {
+  if (sessionId) {
+    return `ge:${sessionId}`;
+  }
+  const date = new Date(timestamp);
+  const day = date.toISOString().split("T")[0];
+  const scopeKey = scope.replace(/[^a-zA-Z0-9:_-]/g, "_").slice(0, 40);
+  return `ge:${scopeKey}:${day}`;
+}
+
+function deriveGeneralEventLabel(
+  scope: string,
+  text: string,
+  timestamp: number,
+): string {
+  const date = new Date(timestamp);
+  const day = date.toISOString().split("T")[0];
+  const eventType = detectEventType(text);
+  const scopeShort = scope.length > 30 ? scope.slice(0, 30) + "\u2026" : scope;
+
+  if (eventType) {
+    return `${eventType} @ ${scopeShort} (${day})`;
+  }
+  return `activity @ ${scopeShort} (${day})`;
+}
+
+function deriveSpecificEventId(scope: string, timestamp: number, textHash: string): string {
+  const prefix = extractScopePrefix(scope);
+  return `se:${prefix}:${timestamp}:${textHash}`;
+}
+
+function deriveSpecificEventLabel(text: string): string {
+  const clean = text.replace(/\s+/g, " ").trim();
+  return clean.length > 60 ? clean.slice(0, 57) + "\u2026" : clean;
+}
+
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+
+/**
+ * Tag a memory with narrative metadata using rule-based heuristics.
+ * Returns null when RECALLNEST_NARRATIVE_MODE is not enabled.
+ */
+export function tagNarrative(params: {
+  scope: string;
+  text: string;
+  timestamp: number;
+  sessionId?: string;
+  sequence?: number;
+}): NarrativeMetadata | null {
+  if (!isNarrativeModeEnabled()) return null;
+
+  const { scope, text, timestamp, sessionId, sequence } = params;
+  const textHash = quickHash(text.slice(0, 200));
+
+  return {
+    lifePeriodId: deriveLifePeriodId(scope, timestamp),
+    lifePeriodLabel: deriveLifePeriodLabel(scope, timestamp),
+    generalEventId: deriveGeneralEventId(scope, timestamp, sessionId),
+    generalEventLabel: deriveGeneralEventLabel(scope, text, timestamp),
+    specificEventId: deriveSpecificEventId(scope, timestamp, textHash),
+    specificEventLabel: deriveSpecificEventLabel(text),
+    startAt: timestamp,
+    endAt: null,
+    sequence: sequence ?? 0,
+  };
+}
+
+/**
+ * Conditionally tag narrative. Returns null when feature flag is off.
+ * Convenience wrapper matching the detectEmotionIfEnabled pattern.
+ */
+export function tagNarrativeIfEnabled(params: {
+  scope: string;
+  text: string;
+  timestamp: number;
+  sessionId?: string;
+  sequence?: number;
+}): NarrativeMetadata | null {
+  return tagNarrative(params);
+}

package/src/pii-detector.ts

@@ -0,0 +1,98 @@
+/**
+ * F-3: Lightweight PII detection.
+ * Scans text for common sensitive patterns (passwords, tokens, IDs).
+ * Returns warnings, does not block writes.
+ */
+
+export type PIISeverity = "high" | "medium" | "low";
+
+export interface PIIDetection {
+  type: string; // "api_key" | "password" | "id_number" | "email" | "phone" | "credit_card"
+  severity: PIISeverity;
+  match: string; // the matched text (partially masked)
+  position: number; // char offset
+}
+
+export interface PIIScanResult {
+  hasPII: boolean;
+  detections: PIIDetection[];
+  summary: string; // human-readable summary
+}
+
+interface PIIRule {
+  type: string;
+  severity: PIISeverity;
+  pattern: RegExp;
+}
+
+const PII_RULES: PIIRule[] = [
+  {
+    type: "api_key",
+    severity: "high",
+    pattern: /(?:sk-[A-Za-z0-9_\-]{20,}|(?:api[_-]?key|token|secret)[=:\s]["']?[A-Za-z0-9_\-]{20,})/gi,
+  },
+  {
+    type: "password",
+    severity: "high",
+    pattern: /(?:password|passwd|pwd)[=:\s]["']?[^\s"']{8,}/gi,
+  },
+  {
+    type: "id_number",
+    severity: "high",
+    pattern: /\d{17}[\dXx]/g,
+  },
+  {
+    type: "credit_card",
+    severity: "high",
+    pattern: /\d{4}[\s-]?\d{4}[\s-]?\d{4}[\s-]?\d{4}/g,
+  },
+  {
+    type: "phone",
+    severity: "medium",
+    pattern: /1[3-9]\d{9}/g,
+  },
+  {
+    type: "email",
+    severity: "low",
+    pattern: /[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/g,
+  },
+];
+
+function maskSensitive(value: string): string {
+  if (value.length <= 8) return value.slice(0, 2) + "***" + value.slice(-2);
+  return value.slice(0, 4) + "***" + value.slice(-4);
+}
+
+/** Scan text for potential PII. Pure regex, no LLM call. */
+export function scanForPII(text: string): PIIScanResult {
+  const detections: PIIDetection[] = [];
+
+  for (const rule of PII_RULES) {
+    // Reset lastIndex for global regexes
+    rule.pattern.lastIndex = 0;
+    let m: RegExpExecArray | null;
+    while ((m = rule.pattern.exec(text)) !== null) {
+      detections.push({
+        type: rule.type,
+        severity: rule.severity,
+        match: maskSensitive(m[0]),
+        position: m.index,
+      });
+    }
+  }
+
+  const high = detections.filter((d) => d.severity === "high").length;
+  const medium = detections.filter((d) => d.severity === "medium").length;
+  const low = detections.filter((d) => d.severity === "low").length;
+
+  const summary =
+    detections.length === 0
+      ? "No PII detected"
+      : `Found ${detections.length} potential PII item${detections.length > 1 ? "s" : ""} (${high} high, ${medium} medium, ${low} low)`;
+
+  return {
+    hasPII: detections.length > 0,
+    detections,
+    summary,
+  };
+}

package/src/post-retrieval-filter.ts

@@ -0,0 +1,76 @@
+/**
+ * E-2: Post-retrieval relevance filter.
+ * After retrieval returns top-K candidates, use LLM to judge relevance.
+ * Only fires for resume_context (batch recall), not search_memory (too slow for interactive).
+ */
+
+import type { LLMClient } from "./llm-client.js";
+import type { RetrievalResult } from "./retriever.js";
+
+export interface FilterConfig {
+  /** Max items to filter per batch (default: 10) */
+  maxItems: number;
+  /** Minimum score to even consider filtering — below this, just drop (default: 0.40) */
+  minScoreForFilter: number;
+}
+
+const DEFAULT_FILTER_CONFIG: FilterConfig = {
+  maxItems: 10,
+  minScoreForFilter: 0.40,
+};
+
+const RELEVANCE_SYSTEM_PROMPT =
+  "你是记忆相关性过滤器。判断以下记忆是否与当前查询相关。\n" +
+  "只输出 JSON 数组：[true, false, true, ...]（与输入顺序对应）";
+
+/**
+ * Filter retrieval results by LLM relevance judgment.
+ * Returns only results judged as relevant.
+ * Falls back to returning all results on LLM failure.
+ */
+export async function filterByRelevance(
+  results: RetrievalResult[],
+  query: string,
+  llm: LLMClient,
+  config?: Partial<FilterConfig>,
+): Promise<RetrievalResult[]> {
+  if (results.length === 0 || !query) return results;
+
+  const cfg: FilterConfig = { ...DEFAULT_FILTER_CONFIG, ...config };
+
+  // Split: items above threshold go to LLM filter, below threshold get dropped
+  const candidates = results.slice(0, cfg.maxItems).filter((r) => r.score >= cfg.minScoreForFilter);
+  if (candidates.length === 0) return [];
+
+  // Build user prompt: query + numbered memory excerpts (first 200 chars)
+  const excerpts = candidates
+    .map((r, i) => `[${i + 1}] ${extractExcerpt(r)}`)
+    .join("\n");
+  const userPrompt = `查询：${query}\n\n记忆列表：\n${excerpts}`;
+
+  try {
+    const verdicts = await llm.chatJson<boolean[]>(RELEVANCE_SYSTEM_PROMPT, userPrompt);
+    if (!Array.isArray(verdicts)) return candidates;
+
+    return candidates.filter((_, i) => i < verdicts.length && verdicts[i] === true);
+  } catch {
+    // Graceful fallback: return all candidates rather than losing data
+    return candidates;
+  }
+}
+
+/** Extract a short excerpt from a result for the LLM prompt. */
+function extractExcerpt(result: RetrievalResult): string {
+  // Prefer l0_abstract from metadata if available, otherwise use raw text
+  if (result.entry.metadata) {
+    try {
+      const meta = JSON.parse(result.entry.metadata) as Record<string, unknown>;
+      if (typeof meta.l0_abstract === "string" && meta.l0_abstract.length > 0) {
+        return meta.l0_abstract.slice(0, 200);
+      }
+    } catch {
+      // Fall through to raw text
+    }
+  }
+  return result.entry.text.slice(0, 200);
+}

package/src/prediction-engine.ts

@@ -0,0 +1,253 @@
+/**
+ * Prediction Engine — HP-predictive (Phase 5)
+ *
+ * Pure heuristic prediction of prospective reminders.
+ * Zero LLM cost — all signals are derived from existing data structures:
+ * - Checkpoint openLoops (stale > 24h = high weight)
+ * - High-frequency but stale memories (not accessed recently)
+ * - Workflow observations with corrected/missed outcomes
+ * - Query topic tags that lack recent memory coverage
+ *
+ * Gated by RECALLNEST_PREDICTIVE_MEMORY=true feature flag.
+ */
+
+import type { SessionCheckpointRecord } from "./session-schema.js";
+import type { WorkflowObservationRecord } from "./workflow-observation-schema.js";
+
+// ============================================================================
+// Types
+// ============================================================================
+
+export interface PredictionSignal {
+  type: "stale_open_loop" | "stale_high_frequency" | "workflow_issue" | "uncovered_topic";
+  trigger: string;
+  action: string;
+  weight: number; // 0-1 raw signal strength
+  evidence: string[];
+}
+
+export interface ScoredPrediction {
+  trigger: string;
+  action: string;
+  confidence: number; // 0-1 final score
+  evidence: string[];
+}
+
+export interface PredictionContext {
+  /** Recent checkpoints (newest first) */
+  checkpoints: SessionCheckpointRecord[];
+  /** Recent workflow observations (newest first) */
+  workflowObservations: WorkflowObservationRecord[];
+  /** High-frequency memory texts + their last access timestamps */
+  frequentMemories: Array<{ text: string; topicTag?: string; lastAccessedAt: string; accessCount: number }>;
+  /** Topic tags from recent queries that had zero or few results */
+  uncoveredTopics: string[];
+  /** Current time for staleness calculation */
+  now?: Date;
+}
+
+// ============================================================================
+// Constants
+// ============================================================================
+
+const CONFIDENCE_THRESHOLD = 0.6;
+const STALE_OPEN_LOOP_HOURS = 24;
+const STALE_MEMORY_DAYS = 14;
+const MAX_PREDICTIONS = 5;
+
+// Signal type weights for final scoring
+const SIGNAL_WEIGHTS: Record<PredictionSignal["type"], number> = {
+  stale_open_loop: 0.9,
+  workflow_issue: 0.85,
+  stale_high_frequency: 0.7,
+  uncovered_topic: 0.65,
+};
+
+// ============================================================================
+// Signal Collection
+// ============================================================================
+
+/**
+ * Collect raw prediction signals from available data sources.
+ * Each signal represents a potential predicted reminder.
+ */
+export function collectSignals(context: PredictionContext): PredictionSignal[] {
+  const now = context.now ?? new Date();
+  const signals: PredictionSignal[] = [];
+
+  // --- Signal 1: Stale open loops from checkpoints ---
+  collectStaleOpenLoopSignals(context.checkpoints, now, signals);
+
+  // --- Signal 2: High-frequency but stale memories ---
+  collectStaleHighFrequencySignals(context.frequentMemories, now, signals);
+
+  // --- Signal 3: Workflow observations with corrected/missed outcomes ---
+  collectWorkflowIssueSignals(context.workflowObservations, signals);
+
+  // --- Signal 4: Uncovered topic tags ---
+  collectUncoveredTopicSignals(context.uncoveredTopics, signals);
+
+  return signals;
+}
+
+function collectStaleOpenLoopSignals(
+  checkpoints: SessionCheckpointRecord[],
+  now: Date,
+  signals: PredictionSignal[],
+): void {
+  const seenLoops = new Set<string>();
+
+  for (const cp of checkpoints) {
+    if (!cp.openLoops || cp.openLoops.length === 0) continue;
+
+    const cpTime = new Date(cp.updatedAt);
+    const hoursAgo = (now.getTime() - cpTime.getTime()) / (1000 * 60 * 60);
+
+    for (const loop of cp.openLoops) {
+      const normalized = loop.toLowerCase().trim();
+      if (seenLoops.has(normalized)) continue;
+      seenLoops.add(normalized);
+
+      if (hoursAgo >= STALE_OPEN_LOOP_HOURS) {
+        // Weight increases with staleness, capped at 1.0
+        const stalenessBoost = Math.min(hoursAgo / (STALE_OPEN_LOOP_HOURS * 3), 1.0);
+        signals.push({
+          type: "stale_open_loop",
+          trigger: loop,
+          action: `Unresolved from ${Math.floor(hoursAgo)}h ago: "${loop}"`,
+          weight: 0.6 + stalenessBoost * 0.4,
+          evidence: [
+            `Open loop from checkpoint ${cp.sessionId} (${Math.floor(hoursAgo)}h ago)`,
+            `Scope: ${cp.resolvedScope ?? cp.scope ?? "unknown"}`,
+          ],
+        });
+      }
+    }
+  }
+}
+
+function collectStaleHighFrequencySignals(
+  memories: PredictionContext["frequentMemories"],
+  now: Date,
+  signals: PredictionSignal[],
+): void {
+  for (const mem of memories) {
+    const lastAccess = new Date(mem.lastAccessedAt);
+    const daysSinceAccess = (now.getTime() - lastAccess.getTime()) / (1000 * 60 * 60 * 24);
+
+    if (daysSinceAccess >= STALE_MEMORY_DAYS && mem.accessCount >= 3) {
+      const stalenessRatio = Math.min(daysSinceAccess / (STALE_MEMORY_DAYS * 3), 1.0);
+      const frequencyBoost = Math.min(mem.accessCount / 10, 1.0);
+      const weight = 0.5 + (stalenessRatio * 0.3) + (frequencyBoost * 0.2);
+
+      const topicLabel = mem.topicTag ? ` [${mem.topicTag}]` : "";
+      const shortText = mem.text.length > 80 ? mem.text.slice(0, 77) + "..." : mem.text;
+
+      signals.push({
+        type: "stale_high_frequency",
+        trigger: mem.topicTag ?? shortText,
+        action: `Revisit frequently-used memory${topicLabel}: "${shortText}"`,
+        weight: Math.min(weight, 1.0),
+        evidence: [
+          `Accessed ${mem.accessCount} times but not in ${Math.floor(daysSinceAccess)} days`,
+          ...(mem.topicTag ? [`Topic: ${mem.topicTag}`] : []),
+        ],
+      });
+    }
+  }
+}
+
+function collectWorkflowIssueSignals(
+  observations: WorkflowObservationRecord[],
+  signals: PredictionSignal[],
+): void {
+  // Group by workflowId, count corrected/missed
+  const issueMap = new Map<string, { count: number; summaries: string[]; latestAt: string }>();
+
+  for (const obs of observations) {
+    if (obs.outcome !== "corrected" && obs.outcome !== "missed") continue;
+
+    const existing = issueMap.get(obs.workflowId);
+    if (existing) {
+      existing.count++;
+      if (existing.summaries.length < 3) existing.summaries.push(obs.summary);
+    } else {
+      issueMap.set(obs.workflowId, {
+        count: 1,
+        summaries: [obs.summary],
+        latestAt: obs.recordedAt,
+      });
+    }
+  }
+
+  for (const [workflowId, data] of issueMap) {
+    if (data.count < 1) continue; // Even a single correction is worth noting
+
+    const weight = Math.min(0.6 + data.count * 0.1, 1.0);
+    signals.push({
+      type: "workflow_issue",
+      trigger: workflowId,
+      action: `Workflow "${workflowId}" had ${data.count} issue(s): ${data.summaries[0]}`,
+      weight,
+      evidence: [
+        `${data.count} corrected/missed observations for workflow "${workflowId}"`,
+        `Latest: ${data.latestAt}`,
+        ...data.summaries.slice(0, 2),
+      ],
+    });
+  }
+}
+
+function collectUncoveredTopicSignals(
+  uncoveredTopics: string[],
+  signals: PredictionSignal[],
+): void {
+  for (const topic of uncoveredTopics) {
+    signals.push({
+      type: "uncovered_topic",
+      trigger: topic,
+      action: `No recent memories for queried topic "${topic}" — consider storing relevant context`,
+      weight: 0.65,
+      evidence: [`Topic "${topic}" appeared in queries but has no recent memory coverage`],
+    });
+  }
+}
+
+// ============================================================================
+// Scoring
+// ============================================================================
+
+/**
+ * Score and rank prediction signals.
+ * Returns top predictions above the confidence threshold.
+ */
+export function scorePredictions(signals: PredictionSignal[]): ScoredPrediction[] {
+  const scored: ScoredPrediction[] = signals.map(signal => {
+    const typeWeight = SIGNAL_WEIGHTS[signal.type];
+    const confidence = Math.round(signal.weight * typeWeight * 100) / 100;
+
+    return {
+      trigger: signal.trigger,
+      action: signal.action,
+      confidence,
+      evidence: signal.evidence,
+    };
+  });
+
+  return scored
+    .filter(p => p.confidence >= CONFIDENCE_THRESHOLD)
+    .sort((a, b) => b.confidence - a.confidence)
+    .slice(0, MAX_PREDICTIONS);
+}
+
+// ============================================================================
+// Exports for testing
+// ============================================================================
+
+export const _testConstants = {
+  CONFIDENCE_THRESHOLD,
+  STALE_OPEN_LOOP_HOURS,
+  STALE_MEMORY_DAYS,
+  MAX_PREDICTIONS,
+  SIGNAL_WEIGHTS,
+} as const;