@remnic/core 1.0.0

package/dist/graph-dashboard-diff.d.ts

@@ -0,0 +1,12 @@
+import { GraphEdge } from './graph.js';
+import { GraphSnapshot } from './graph-dashboard-parser.js';
+
+interface GraphPatch {
+    addedNodes: string[];
+    removedNodes: string[];
+    addedEdges: GraphEdge[];
+    removedEdges: GraphEdge[];
+}
+declare function diffGraphSnapshots(previous: GraphSnapshot, next: GraphSnapshot): GraphPatch;
+
+export { type GraphPatch, diffGraphSnapshots };

package/dist/graph-dashboard-diff.js

@@ -0,0 +1,8 @@
+import {
+  diffGraphSnapshots
+} from "./chunk-3SLRNYNG.js";
+import "./chunk-Y4Z4I6WK.js";
+export {
+  diffGraphSnapshots
+};
+//# sourceMappingURL=graph-dashboard-diff.js.map

package/dist/graph-dashboard-diff.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/graph-dashboard-key.d.ts

@@ -0,0 +1,5 @@
+import { GraphEdge } from './graph.js';
+
+declare function graphEdgeKey(edge: GraphEdge): string;
+
+export { graphEdgeKey };

package/dist/graph-dashboard-key.js

@@ -0,0 +1,7 @@
+import {
+  graphEdgeKey
+} from "./chunk-Y4Z4I6WK.js";
+export {
+  graphEdgeKey
+};
+//# sourceMappingURL=graph-dashboard-key.js.map

package/dist/graph-dashboard-key.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/graph-dashboard-parser.d.ts

@@ -0,0 +1,20 @@
+import { GraphEdge, GraphType } from './graph.js';
+
+interface GraphSnapshotNode {
+    id: string;
+}
+interface GraphSnapshotStats {
+    nodes: number;
+    edges: number;
+    malformedLines: number;
+    filesMissing: GraphType[];
+}
+interface GraphSnapshot {
+    generatedAt: string;
+    nodes: GraphSnapshotNode[];
+    edges: GraphEdge[];
+    stats: GraphSnapshotStats;
+}
+declare function graphSnapshotFromMemoryDir(memoryDir: string): Promise<GraphSnapshot>;
+
+export { type GraphSnapshot, type GraphSnapshotNode, type GraphSnapshotStats, graphSnapshotFromMemoryDir };

package/dist/graph-dashboard-parser.js

@@ -0,0 +1,8 @@
+import {
+  graphSnapshotFromMemoryDir
+} from "./chunk-LIRZNNUP.js";
+import "./chunk-Y4Z4I6WK.js";
+export {
+  graphSnapshotFromMemoryDir
+};
+//# sourceMappingURL=graph-dashboard-parser.js.map

package/dist/graph-dashboard-parser.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/graph.d.ts

@@ -0,0 +1,157 @@
+/**
+ * Multi-Graph Memory (MAGMA/SYNAPSE-inspired, v8.2)
+ *
+ * Maintains three typed edge graphs:
+ *   entity.jsonl  — memories sharing a named entity (entityRef)
+ *   time.jsonl    — consecutive memories in the same thread/session
+ *   causal.jsonl  — memories linked by causal language heuristics
+ *
+ * Stored under `<memoryDir>/state/graphs/`.
+ * All writes are fail-open: errors are caught/logged, never thrown.
+ */
+type GraphType = "entity" | "time" | "causal";
+interface GraphEdge {
+    from: string;
+    to: string;
+    type: GraphType;
+    weight: number;
+    label: string;
+    ts: string;
+}
+interface GraphConfig {
+    multiGraphMemoryEnabled: boolean;
+    entityGraphEnabled: boolean;
+    timeGraphEnabled: boolean;
+    causalGraphEnabled: boolean;
+    maxGraphTraversalSteps: number;
+    graphActivationDecay: number;
+    maxEntityGraphEdgesPerMemory: number;
+    graphLateralInhibitionEnabled: boolean;
+    graphLateralInhibitionBeta: number;
+    graphLateralInhibitionTopM: number;
+}
+declare const CAUSAL_PHRASES: string[];
+declare function graphsDir(memoryDir: string): string;
+declare function graphFilePath(memoryDir: string, type: GraphType): string;
+declare function ensureGraphsDir(memoryDir: string): Promise<void>;
+declare function appendEdge(memoryDir: string, edge: GraphEdge): Promise<void>;
+/**
+ * Read all edges of a given type from the JSONL file.
+ * Returns [] if the file doesn't exist or is corrupt (fail-open).
+ */
+declare function readEdges(memoryDir: string, type: GraphType): Promise<GraphEdge[]>;
+/**
+ * Read edges from all enabled graph types.
+ */
+declare function readAllEdges(memoryDir: string, config: Pick<GraphConfig, "entityGraphEnabled" | "timeGraphEnabled" | "causalGraphEnabled">): Promise<GraphEdge[]>;
+interface GraphHealthFileStats {
+    type: GraphType;
+    filePath: string;
+    exists: boolean;
+    totalLines: number;
+    validEdges: number;
+    corruptLines: number;
+    uniqueNodes: number;
+}
+interface GraphHealthReport {
+    generatedAt: string;
+    enabledTypes: GraphType[];
+    totals: {
+        totalLines: number;
+        validEdges: number;
+        corruptLines: number;
+        uniqueNodes: number;
+    };
+    files: GraphHealthFileStats[];
+    repairGuidance?: string[];
+}
+declare function analyzeGraphHealth(memoryDir: string, options?: {
+    entityGraphEnabled?: boolean;
+    timeGraphEnabled?: boolean;
+    causalGraphEnabled?: boolean;
+    includeRepairGuidance?: boolean;
+}): Promise<GraphHealthReport>;
+/**
+ * Detect causal signal phrases in text. Returns the first matched phrase, or null.
+ */
+declare function detectCausalPhrase(text: string): string | null;
+/**
+ * GraphIndex — builds and updates the three memory graphs.
+ *
+ * Usage (orchestrator):
+ *   this.graphIndex = new GraphIndex(config.memoryDir, config);
+ *
+ *   // After each memory write:
+ *   await this.graphIndex.onMemoryWritten(memoryPath, frontmatter, threadId, recentInThread);
+ */
+declare class GraphIndex {
+    private readonly memoryDir;
+    private readonly cfg;
+    private edgeCache;
+    private static readonly EDGE_CACHE_TTL_MS;
+    constructor(memoryDir: string, cfg: GraphConfig);
+    /** Clear the edge cache so the next spreadingActivation() re-reads from disk.
+     *  Call after any code path that appends edges outside of onMemoryWritten(). */
+    invalidateEdgeCache(): void;
+    private loadEdgesCached;
+    /**
+     * Called after a memory is written to disk.
+     *
+     * @param memoryPath - relative path from memoryDir (e.g. "facts/2026-02-22/abc.md")
+     * @param entityRef  - entityRef frontmatter field (if any)
+     * @param content    - full memory text (for causal detection)
+     * @param created    - ISO timestamp of this memory
+     * @param threadId   - current thread ID (for time graph)
+     * @param recentInThread - paths of the N most-recent memories in this thread (for time graph)
+     * @param entitySiblings - paths of other memories that share the same entityRef (for entity graph)
+     */
+    onMemoryWritten(opts: {
+        memoryPath: string;
+        entityRef?: string;
+        content: string;
+        created: string;
+        threadId?: string;
+        recentInThread?: string[];
+        entitySiblings?: string[];
+        causalPredecessor?: string;
+    }): Promise<void>;
+    /**
+     * Spreading activation BFS (SYNAPSE-inspired).
+     *
+     * Starting from `seeds`, traverse the combined graph for up to `maxSteps` hops.
+     * Each candidate gets an activation score = edge.weight × decay^hop.
+     * Returns top-N candidate paths sorted by descending activation score.
+     *
+     * @param seeds   - initial memory paths to expand from (e.g. QMD top results)
+     * @param maxSteps - max BFS hops (from config: maxGraphTraversalSteps)
+     * @returns Array of {path, score} sorted descending, not including seed paths
+     */
+    spreadingActivation(seeds: string[], maxSteps?: number): Promise<Array<{
+        path: string;
+        score: number;
+        seed: string;
+        hopDepth: number;
+        decayedWeight: number;
+        graphType: "entity" | "time" | "causal";
+    }>>;
+}
+/**
+ * Lateral inhibition (Synapse-inspired).
+ *
+ * For each node, the top-M higher-activation competitors exert inhibition
+ * proportional to their activation difference. Output is clamped to [0, ∞).
+ *
+ * No sigmoid is applied here — downstream `normalizeGraphActivationScore`
+ * already applies x/(1+x) soft squash, so adding a sigmoid would double-
+ * normalize and cap graph influence at ~50%.
+ *
+ * Formula: u_hat_i = max(0, u_i - beta * sum_{k in top-M where u_k > u_i}(u_k - u_i))
+ *
+ * When beta=0 or topM=0, returns original scores unchanged (no-op).
+ */
+declare function applyLateralInhibition(scores: Map<string, number>, opts: {
+    beta: number;
+    topM: number;
+}): Map<string, number>;
+
+export { CAUSAL_PHRASES, type GraphConfig, type GraphEdge, type GraphHealthFileStats, type GraphHealthReport, GraphIndex, type GraphType, analyzeGraphHealth, appendEdge, applyLateralInhibition, detectCausalPhrase, ensureGraphsDir, graphFilePath, graphsDir, readAllEdges, readEdges };

package/dist/graph.js

@@ -0,0 +1,27 @@
+import {
+  CAUSAL_PHRASES,
+  GraphIndex,
+  analyzeGraphHealth,
+  appendEdge,
+  applyLateralInhibition,
+  detectCausalPhrase,
+  ensureGraphsDir,
+  graphFilePath,
+  graphsDir,
+  readAllEdges,
+  readEdges
+} from "./chunk-SCHEKPYH.js";
+export {
+  CAUSAL_PHRASES,
+  GraphIndex,
+  analyzeGraphHealth,
+  appendEdge,
+  applyLateralInhibition,
+  detectCausalPhrase,
+  ensureGraphsDir,
+  graphFilePath,
+  graphsDir,
+  readAllEdges,
+  readEdges
+};
+//# sourceMappingURL=graph.js.map

package/dist/graph.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/harmonic-retrieval.d.ts

@@ -0,0 +1,27 @@
+import { AbstractionNode } from './abstraction-nodes.js';
+import { CueAnchorType } from './cue-anchors.js';
+
+interface HarmonicMatchedAnchor {
+    anchorId: string;
+    anchorType: CueAnchorType;
+    anchorValue: string;
+}
+interface HarmonicRetrievalResult {
+    node: AbstractionNode;
+    score: number;
+    nodeScore: number;
+    anchorScore: number;
+    matchedFields: string[];
+    matchedAnchors: HarmonicMatchedAnchor[];
+}
+declare function searchHarmonicRetrieval(options: {
+    memoryDir: string;
+    abstractionNodeStoreDir?: string;
+    query: string;
+    maxResults: number;
+    sessionKey?: string;
+    anchorsEnabled: boolean;
+    abortSignal?: AbortSignal;
+}): Promise<HarmonicRetrievalResult[]>;
+
+export { type HarmonicMatchedAnchor, type HarmonicRetrievalResult, searchHarmonicRetrieval };

package/dist/harmonic-retrieval.js

@@ -0,0 +1,12 @@
+import {
+  searchHarmonicRetrieval
+} from "./chunk-AAI7JARD.js";
+import "./chunk-C6QPK5GG.js";
+import "./chunk-NGAVDO7E.js";
+import "./chunk-DT5TVLJE.js";
+import "./chunk-DGXUHMOV.js";
+import "./chunk-LPSF4OQH.js";
+export {
+  searchHarmonicRetrieval
+};
+//# sourceMappingURL=harmonic-retrieval.js.map

package/dist/harmonic-retrieval.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/himem.d.ts

@@ -0,0 +1,23 @@
+/**
+ * HiMem — Episode/Note dual store (v8.0 Phase 2B)
+ *
+ * Classifies extracted memories as:
+ *   episode — time-specific events, actions, observations (event fidelity)
+ *   note    — stable beliefs, preferences, decisions, constraints
+ *
+ * Based on the HiMem paper: episodes are ephemeral, notes are reconsolidated
+ * into a stable belief layer. This classification gates reconsolidation.
+ */
+type MemoryKind = "episode" | "note";
+/**
+ * Classify a memory fact as "episode" (time-specific event) or "note"
+ * (stable belief/preference/decision).
+ *
+ * @param content   - The memory's text content
+ * @param tags      - Tags from extraction (checked for episode/note signals)
+ * @param category  - Category from extraction
+ * @returns "episode" | "note"
+ */
+declare function classifyMemoryKind(content: string, tags: string[], category: string): MemoryKind;
+
+export { type MemoryKind, classifyMemoryKind };

package/dist/himem.js

@@ -0,0 +1,7 @@
+import {
+  classifyMemoryKind
+} from "./chunk-YAZNBMNF.js";
+export {
+  classifyMemoryKind
+};
+//# sourceMappingURL=himem.js.map

package/dist/himem.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/hygiene.d.ts

@@ -0,0 +1,24 @@
+type HygieneWarning = {
+    path: string;
+    bytes: number;
+    budgetBytes: number;
+    warnAtBytes: number;
+    message: string;
+};
+declare function lintWorkspaceFiles(opts: {
+    workspaceDir: string;
+    paths: string[];
+    budgetBytes: number;
+    warnRatio: number;
+}): Promise<HygieneWarning[]>;
+declare function rotateMarkdownFileToArchive(opts: {
+    filePath: string;
+    archiveDir: string;
+    archivePrefix: string;
+    keepTailChars: number;
+}): Promise<{
+    archivedPath: string;
+    newContent: string;
+}>;
+
+export { type HygieneWarning, lintWorkspaceFiles, rotateMarkdownFileToArchive };

package/dist/hygiene.js

@@ -0,0 +1,9 @@
+import {
+  lintWorkspaceFiles,
+  rotateMarkdownFileToArchive
+} from "./chunk-DM2T26WE.js";
+export {
+  lintWorkspaceFiles,
+  rotateMarkdownFileToArchive
+};
+//# sourceMappingURL=hygiene.js.map

package/dist/hygiene.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/identity-continuity.d.ts

@@ -0,0 +1,17 @@
+import { ContinuityIncidentRecord, ContinuityIncidentCloseInput, ContinuityIncidentOpenInput, ContinuityImprovementLoop, ContinuityLoopReviewInput, ContinuityLoopUpsertInput } from './types.js';
+
+declare function serializeContinuityIncident(incident: ContinuityIncidentRecord): string;
+declare function parseContinuityIncident(raw: string): ContinuityIncidentRecord | null;
+declare function createContinuityIncidentRecord(id: string, input: ContinuityIncidentOpenInput, nowIso: string): ContinuityIncidentRecord;
+declare function closeContinuityIncidentRecord(incident: ContinuityIncidentRecord, closure: ContinuityIncidentCloseInput, nowIso: string): ContinuityIncidentRecord;
+declare function parseContinuityImprovementLoops(raw: string): ContinuityImprovementLoop[];
+declare function upsertContinuityLoopInMarkdown(raw: string | null, input: ContinuityLoopUpsertInput, nowIso: string): {
+    markdown: string;
+    loop: ContinuityImprovementLoop;
+};
+declare function reviewContinuityLoopInMarkdown(raw: string | null, id: string, input: ContinuityLoopReviewInput, nowIso: string): {
+    markdown: string;
+    loop: ContinuityImprovementLoop | null;
+};
+
+export { closeContinuityIncidentRecord, createContinuityIncidentRecord, parseContinuityImprovementLoops, parseContinuityIncident, reviewContinuityLoopInMarkdown, serializeContinuityIncident, upsertContinuityLoopInMarkdown };

package/dist/identity-continuity.js

@@ -0,0 +1,19 @@
+import {
+  closeContinuityIncidentRecord,
+  createContinuityIncidentRecord,
+  parseContinuityImprovementLoops,
+  parseContinuityIncident,
+  reviewContinuityLoopInMarkdown,
+  serializeContinuityIncident,
+  upsertContinuityLoopInMarkdown
+} from "./chunk-QSVPYQPG.js";
+export {
+  closeContinuityIncidentRecord,
+  createContinuityIncidentRecord,
+  parseContinuityImprovementLoops,
+  parseContinuityIncident,
+  reviewContinuityLoopInMarkdown,
+  serializeContinuityIncident,
+  upsertContinuityLoopInMarkdown
+};
+//# sourceMappingURL=identity-continuity.js.map

package/dist/identity-continuity.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/importance.d.ts

@@ -0,0 +1,25 @@
+import { ImportanceLevel, MemoryFile, ImportanceScore, MemoryCategory } from './types.js';
+
+/**
+ * Local Importance Scoring (Phase 1B)
+ *
+ * Zero-LLM heuristic system that evaluates each memory's significance.
+ * Analyzes content for markers like explicit importance statements,
+ * personal information, instructions, emotional content, and factual density.
+ */
+
+/**
+ * Calculate importance score for a memory.
+ * Pure local heuristics, zero LLM calls.
+ */
+declare function scoreImportance(content: string, category: MemoryCategory, tags?: string[]): ImportanceScore;
+/**
+ * Recompute importance for an existing memory file using current local heuristics.
+ */
+declare function rescoreMemoryImportance(memory: MemoryFile): ImportanceScore;
+/**
+ * Get importance level from numeric score.
+ */
+declare function importanceLevel(score: number): ImportanceLevel;
+
+export { importanceLevel, rescoreMemoryImportance, scoreImportance };

package/dist/importance.js

@@ -0,0 +1,11 @@
+import {
+  importanceLevel,
+  rescoreMemoryImportance,
+  scoreImportance
+} from "./chunk-BDFZXRSO.js";
+export {
+  importanceLevel,
+  rescoreMemoryImportance,
+  scoreImportance
+};
+//# sourceMappingURL=importance.js.map

package/dist/importance.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}