@remnic/core 9.50.3 → 9.51.1

package/dist/extraction.js

@@ -1,9 +1,9 @@
 import {
   ExtractionEngine,
   shouldEnableLocalExtractionThinking
-} from "./chunk-S3AYIQCU.js";
+} from "./chunk-AXIDQG5A.js";
 import "./chunk-4RA3C3EV.js";
-import "./chunk-NO37MR45.js";
+import "./chunk-SOEN6KCF.js";
 import "./chunk-WFLBP5GC.js";
 import "./chunk-54V4BZWP.js";
 import "./chunk-2CGLBUW3.js";
@@ -11,6 +11,8 @@ import "./chunk-WLZYGLJ4.js";
 import "./chunk-L6CQ7WIW.js";
 import "./chunk-WKDFJXW5.js";
 import "./chunk-JUXOTY6J.js";
+import "./chunk-AMTEYNYK.js";
+import "./chunk-EEAMSNSG.js";
 import "./chunk-NK5RGJ65.js";
 import "./chunk-4POAMKV6.js";
 import "./chunk-WAS4HV46.js";
@@ -18,10 +20,8 @@ import {
   classifyExtractionThrownError,
   classifyFallbackParseFailure
 } from "./chunk-BLDBT6HZ.js";
-import "./chunk-AMTEYNYK.js";
-import "./chunk-EEAMSNSG.js";
-import "./chunk-RPSYDM6C.js";
 import "./chunk-VEWZZM3H.js";
+import "./chunk-RPSYDM6C.js";
 import "./chunk-C7SRUWBW.js";
 import "./chunk-JLNBQWZ2.js";
 import "./chunk-QW27DOHG.js";
@@ -31,23 +31,23 @@ import "./chunk-RZRUV6N2.js";
 import "./chunk-EMDLM3LW.js";
 import "./chunk-NLE6TSLG.js";
 import "./chunk-QDW3E4RD.js";
-import "./chunk-4MBPIL4V.js";
+import "./chunk-PUSLMZBQ.js";
 import "./chunk-KSXJOC4F.js";
-import "./chunk-BOFVT6P3.js";
-import "./chunk-ENTCVTQR.js";
+import "./chunk-VBHPOWBJ.js";
 import "./chunk-UHVXE24Y.js";
+import "./chunk-ENTCVTQR.js";
 import "./chunk-SXIMQLGV.js";
 import "./chunk-S2V7RUCL.js";
 import "./chunk-J6A3CX5N.js";
-import "./chunk-LAQ33B5D.js";
-import "./chunk-S2HLHAZ4.js";
+import "./chunk-UU3G6GUP.js";
 import "./chunk-SCU65EZI.js";
 import "./chunk-WRJVB3C2.js";
+import "./chunk-S2HLHAZ4.js";
 import "./chunk-DM2T26WE.js";
 import "./chunk-LDXUBPMO.js";
 import "./chunk-JYIJNNN3.js";
 import "./chunk-AAD2ZS6P.js";
-import "./chunk-IXXABW5A.js";
+import "./chunk-BHXYAVUM.js";
 import "./chunk-5V6IXHPI.js";
 import "./chunk-BT7NVCML.js";
 import "./chunk-R3DJVOSM.js";
@@ -60,28 +60,29 @@ import "./chunk-RBOJCG4T.js";
 import "./chunk-M4A44LUA.js";
 import "./chunk-EWMTOVMY.js";
 import "./chunk-6CIAGZ6X.js";
-import "./chunk-N3LL5NEU.js";
-import "./chunk-PD6O7AXF.js";
-import "./chunk-RVO6TCTU.js";
-import "./chunk-URS5GSM7.js";
-import "./chunk-IUM3VSHI.js";
-import "./chunk-ZLQ37WJX.js";
-import "./chunk-OD4FM2U7.js";
-import "./chunk-XMMESCPD.js";
-import "./chunk-42JKGUFJ.js";
 import "./chunk-C23BYTJV.js";
 import "./chunk-QIEUU4UK.js";
 import "./chunk-L2EXJQJP.js";
 import "./chunk-45GF7Y3V.js";
 import "./chunk-RGMVMVMF.js";
 import "./chunk-N7RWREIQ.js";
+import "./chunk-ZMYDYNI4.js";
+import "./chunk-PD6O7AXF.js";
+import "./chunk-QCECHYZL.js";
+import "./chunk-URS5GSM7.js";
+import "./chunk-ZLQ37WJX.js";
+import "./chunk-IUM3VSHI.js";
+import "./chunk-OD4FM2U7.js";
+import "./chunk-XMMESCPD.js";
+import "./chunk-42JKGUFJ.js";
 import "./chunk-K6MV3TRQ.js";
 import "./chunk-QBSFOKY6.js";
-import "./chunk-ZIKENA2C.js";
 import "./chunk-5GKPFL3S.js";
+import "./chunk-ZIKENA2C.js";
 import "./chunk-PQVCH2AE.js";
 import "./chunk-6MKAMLQL.js";
 import "./chunk-JAKIDQB2.js";
+import "./chunk-W5BIQOAJ.js";
 import "./chunk-Z7L72ZHL.js";
 import "./chunk-4O4TKIXQ.js";
 import "./chunk-ZBJMUXZH.js";

package/dist/fallback-llm.d.ts

@@ -1,9 +1,11 @@
-import { G as GatewayConfig, A as AgentPersonaModelConfig, P as PluginConfig } from './types-u2s9j1uD.js';
+import { G as GatewayConfig, A as AgentPersonaModelConfig, P as PluginConfig } from './types-CkiDUorT.js';
 import { GetRuntimeAuthForModelFn, ResolveApiKeyFn } from './resolve-provider-secret.js';
 import './message-parts/index.js';
 import './bounded-jsonl-state.js';
 import './operator-doctor-types.js';
 import './external-wiki-config.js';
+import './contradiction-config.js';
+import './graph-path-scoring-config.js';
 import './types-continuity.js';
 
 interface FallbackLlmOptions {

package/dist/graph-444E-DrF.d.ts

@@ -0,0 +1,349 @@
+import { GraphConstructionCapabilitySet } from './capabilities.js';
+
+interface ActivationPredecessor {
+    prev: string;
+    edgeConfidence: number;
+    graphType: GraphType;
+}
+interface ActivationPathCandidate {
+    hopDepth: number;
+    landingStrength: number;
+    pathKey: string;
+}
+/** Compare path winners: fewer hops, stronger landing, then lexical path order. */
+declare function compareActivationPathCandidates(left: ActivationPathCandidate, right: ActivationPathCandidate): number;
+declare class ActivationPathTracker {
+    readonly predecessors: Map<string, ActivationPredecessor>;
+    private readonly winners;
+    private readonly pathKeys;
+    constructor(seeds: Iterable<string>);
+    consider(seed: string, node: string, neighbor: string, hopDepth: number, landingStrength: number, edgeConfidence: number, graphType: GraphType): string;
+}
+declare function reconstructActivationPath(seed: string, candidate: string, predecessors: Map<string, ActivationPredecessor>, maxSteps: number): ActivationPath | null;
+
+/**
+ * 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 ActivationPath {
+    /** Node ids from the seed (inclusive) to the reached node (inclusive). */
+    nodeIds: string[];
+    /** Edge confidences, parallel to the hops in {@link nodeIds}. */
+    edgeConfidences: number[];
+    /** Graph types, parallel to the hops in {@link nodeIds}. */
+    graphTypes: GraphType[];
+}
+interface GraphEdge {
+    from: string;
+    to: string;
+    type: GraphType;
+    weight: number;
+    label: string;
+    ts: string;
+    confidence?: number;
+    lastReinforcedAt?: string;
+}
+interface GraphConfig {
+    multiGraphMemoryEnabled: boolean;
+    entityGraphEnabled: boolean;
+    timeGraphEnabled: boolean;
+    causalGraphEnabled: boolean;
+    maxGraphTraversalSteps: number;
+    graphActivationDecay: number;
+    maxEntityGraphEdgesPerMemory: number;
+    graphLateralInhibitionEnabled: boolean;
+    graphLateralInhibitionBeta: number;
+    graphLateralInhibitionTopM: number;
+    /**
+     * Issue #681 PR 3/3 — minimum edge confidence required for traversal.
+     * Edges with confidence below this floor are pruned. Legacy edges
+     * (no `confidence` field) are treated as 1.0 and always pass.
+     * Range `[0, 1]`. Default 0.2.
+     */
+    graphTraversalConfidenceFloor: number;
+    /**
+     * Issue #681 PR 3/3 — number of PageRank-style refinement iterations
+     * applied on top of BFS activation. Set to 0 to disable refinement
+     * and return raw BFS scores. Default 8.
+     */
+    graphTraversalPageRankIterations: number;
+    /**
+     * Issue #1904 — incremental GraphIndex edge cache. When true (the default,
+     * and the value when omitted), a single-writer edge append is pushed into the
+     * warm edge cache in place (revalidated by file size for cross-process
+     * coherence) instead of nulling the cache and paying a full 6 MB re-read +
+     * parse on the next traversal. Set false to restore the pre-#1904
+     * null-on-every-write behavior. Optional here (unlike the required
+     * PluginConfig field parseConfig always sets) so GraphConfig can still be
+     * constructed directly with a partial config; only an explicit `false` opts
+     * out, so an omitted field keeps the incremental default.
+     */
+    graphEdgeCacheIncrementalEnabled?: boolean;
+}
+/** Default minimum edge confidence required for traversal (issue #681 PR 3/3). */
+declare const DEFAULT_GRAPH_TRAVERSAL_CONFIDENCE_FLOOR = 0.2;
+/** Default PageRank-style refinement iteration count (issue #681 PR 3/3). */
+declare const DEFAULT_GRAPH_TRAVERSAL_PAGERANK_ITERATIONS = 8;
+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>;
+/**
+ * Run `fn` while holding the write lock for the given graph JSONL file.
+ *
+ * The lock is keyed by absolute file path so concurrent writes to
+ * different graph types proceed independently. The chain recovers from
+ * rejection (gotcha #40) so a single I/O failure does not poison all
+ * future writers, but the original error is still surfaced to the
+ * caller of `withGraphWriteLock`.
+ */
+declare function withGraphWriteLock<T>(filePath: string, fn: () => Promise<T>): Promise<T>;
+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 any read error occurs (fail-open).
+ *
+ * Production traversal callers (recall/PageRank) depend on this fail-open
+ * posture so a temporarily missing or unreadable graph file never blocks
+ * a recall. Maintenance jobs that need to distinguish ENOENT from real
+ * I/O failures must use {@link readEdgesStrict} instead.
+ */
+declare function readEdges(memoryDir: string, type: GraphType): Promise<GraphEdge[]>;
+/**
+ * Same as {@link readEdges} but only swallows `ENOENT`; all other read
+ * errors (`EACCES`, `EIO`, …) are propagated. Used by the graph-edge
+ * decay maintenance job so I/O outages surface as a failed run instead
+ * of being silently reported as "no edges to decay" (issue #729 /
+ * Codex P1, line 120).
+ */
+declare function readEdgesStrict(memoryDir: string, type: GraphType): Promise<GraphEdge[]>;
+/**
+ * Read edges from all enabled graph types.
+ */
+declare function readAllEdges(memoryDir: string, graphCaps: Pick<GraphConstructionCapabilitySet, "entityGraph" | "timeGraph" | "causalGraph">): 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;
+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;
+    /**
+     * Identity ({ size, mtimeMs, ino }) of each ENABLED graph file (issue #1904).
+     * Missing files (ENOENT) and any stat error map to the all-zero sentinel so
+     * the baseline is fail-open: a later revalidation sees a mismatch (or a peer
+     * creation flipping ino from 0 to non-zero) and forces a full reload rather
+     * than trusting a stale incremental push.
+     */
+    private readEnabledGraphFileMeta;
+    /** True iff both metadata maps carry identical identity for every key. */
+    private graphFileMetaEqual;
+    /**
+     * Re-stat every graph file whose identity the cache just committed and return
+     * false if any has moved since (issue #1904, Codex). Closes the validation→
+     * in-place-push TOCTOU window: a peer process (concurrent CLI / daemon /
+     * decay job) can append between edgeFilesUnchangedExceptOurAppends()'s final
+     * stat and the allEdges.push(...). Without this re-check the cache would be
+     * accepted with identity predating the peer write and miss the peer edge for
+     * the TTL. A residual infinitesimal window (peer writes during this re-stat)
+     * remains and is TTL-bounded.
+     */
+    private edgeCacheIdentityUnchangedSinceCommit;
+    /**
+     * 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;
+        /**
+         * Optional frozen gate overrides (from GraphConstructionCapabilitySet).
+         * When provided, these take precedence over `this.cfg` so the caller's
+         * operation-scoped snapshot is the single source of truth (#1566).
+         */
+        graphCapsOverride?: {
+            entityGraph: boolean;
+            timeGraph: boolean;
+            causalGraph: boolean;
+            multiGraphMemory: boolean;
+        };
+    }): Promise<void>;
+    /**
+     * Cross-process coherence check for the incremental edge cache (issue #1904).
+     *
+     * Returns true iff every ENABLED graph file's current identity is explained
+     * ENTIRELY by THIS call's own append — no other process wrote to any graph
+     * file since load. Per file:
+     *   - inode must be unchanged. A local append (`appendFile`) keeps the inode;
+     *     an external atomic temp+rename rewrite (e.g. the edge-decay job) changes
+     *     it, so an inode change — even one that preserves byte length, such as
+     *     decaying confidence 0.9->0.8 — forces a reload (Codex).
+     *   - a file WE appended to (delta > 0): size must equal baseline + our exact
+     *     appended bytes. If it was absent at load (sentinel ino 0), our append
+     *     created it, so we accept size === delta and adopt the new identity.
+     *   - a file we did NOT touch (delta 0): size AND mtime must be unchanged, so
+     *     an in-place equal-length rewrite (mtime bump) or a peer append (size
+     *     bump) both force a reload.
+     * On success it commits the new identity baseline so the next append
+     * revalidates against post-this-write truth. Fail-open: an unreadable file
+     * (non-ENOENT) returns false, forcing a full reload.
+     */
+    private edgeFilesUnchangedExceptOurAppends;
+    /**
+     * 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 × edgeConfidence × decay^hop.
+     *
+     * Issue #681 PR 3/3 — confidence-aware traversal:
+     *   - Each edge's `weight` is multiplied by its `confidence` (legacy edges
+     *     missing `confidence` are treated as 1.0, preserving prior behavior).
+     *   - Edges with `confidence < graphTraversalConfidenceFloor` are pruned and
+     *     contribute neither activation nor downstream neighbors.
+     *   - When `graphTraversalPageRankIterations > 0`, an additional PageRank-
+     *     style refinement pass redistributes activation along confidence-weighted
+     *     edges, sharpening the ranking among multi-hop candidates.
+     *   - Per-result provenance includes the highest-confidence edge that landed
+     *     on each candidate, so the X-ray surface can attribute pruning and
+     *     ranking decisions back to specific edges.
+     *
+     * @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, edgeConfidence, ...} sorted descending, not including seed paths
+     */
+    spreadingActivation(seeds: string[], maxSteps?: number, opts?: {
+        /**
+         * Issue #681 — when `true`, bypasses the configured
+         * `graphTraversalConfidenceFloor` and includes low-confidence
+         * edges in traversal.  Equivalent to forcing the floor to `0`.
+         * Default `false` (floor from config is applied).
+         */
+        includeLowConfidence?: boolean;
+        /** Record one shortest seed-to-candidate path in each result. */
+        recordPaths?: boolean;
+        /** Absolute deadline in ms-since-epoch for post-retrieval assembly. */
+        deadlineAtMs?: number;
+    }): Promise<Array<{
+        path: string;
+        score: number;
+        seed: string;
+        hopDepth: number;
+        decayedWeight: number;
+        graphType: "entity" | "time" | "causal";
+        /**
+         * Confidence of the edge that produced this candidate's recorded
+         * provenance (the strongest edge along the chosen entry path).
+         * In `[0, 1]`. Legacy edges without `confidence` surface as 1.0.
+         */
+        edgeConfidence: number;
+        activationPath?: ActivationPath | null;
+    }>>;
+}
+/**
+ * Clamp `graphTraversalConfidenceFloor` into the legal range `[0, 1]`.
+ * Non-finite or non-numeric values fall back to the documented default
+ * so misconfiguration cannot silently disable the floor or reject every edge.
+ *
+ * Exported for tests; call sites in `spreadingActivation` use it to make
+ * the contract explicit at every boundary.
+ */
+declare function clampConfidenceFloor(raw: unknown): number;
+/**
+ * Clamp `graphTraversalPageRankIterations` into a non-negative integer.
+ * Negative or non-finite values fall back to 0 (disable refinement) so
+ * misconfiguration cannot stall recall in an unbounded loop.
+ */
+declare function clampPageRankIterations(raw: unknown): number;
+/**
+ * PageRank-style refinement on top of the BFS activation map.
+ *
+ * Each iteration redistributes a fraction of every node's score along
+ * its outgoing edges, scaled by edge confidence. Confidence below
+ * `floor` is filtered out before redistribution, mirroring the BFS
+ * pruning rule. Mutates `scores` in place.
+ *
+ * Exported for tests; in production, call sites pass the same adjacency
+ * map already used by BFS so behavior stays consistent.
+ */
+declare function applyPageRankRefinement(scores: Map<string, number>, adj: Map<string, GraphEdge[]>, opts: {
+    iterations: number;
+    floor: number;
+    damping: number;
+    deadlineAtMs?: number;
+}): void;
+/**
+ * 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 { type ActivationPath as A, CAUSAL_PHRASES as C, DEFAULT_GRAPH_TRAVERSAL_CONFIDENCE_FLOOR as D, type GraphType as G, type GraphEdge as a, type GraphHealthReport as b, GraphIndex as c, type ActivationPathCandidate as d, ActivationPathTracker as e, type ActivationPredecessor as f, compareActivationPathCandidates as g, DEFAULT_GRAPH_TRAVERSAL_PAGERANK_ITERATIONS as h, type GraphConfig as i, type GraphHealthFileStats as j, analyzeGraphHealth as k, appendEdge as l, applyLateralInhibition as m, applyPageRankRefinement as n, clampConfidenceFloor as o, clampPageRankIterations as p, detectCausalPhrase as q, reconstructActivationPath as r, ensureGraphsDir as s, graphFilePath as t, graphsDir as u, readAllEdges as v, readEdges as w, readEdgesStrict as x, withGraphWriteLock as y };

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

@@ -1,11 +1,13 @@
-import { GraphEdge } from './graph.js';
+import { a as GraphEdge } from './graph-444E-DrF.js';
 import { GraphSnapshot } from './graph-dashboard-parser.js';
 import './capabilities.js';
-import './types-u2s9j1uD.js';
+import './types-CkiDUorT.js';
 import './message-parts/index.js';
 import './bounded-jsonl-state.js';
 import './operator-doctor-types.js';
 import './external-wiki-config.js';
+import './contradiction-config.js';
+import './graph-path-scoring-config.js';
 import './types-continuity.js';
 
 interface GraphPatch {

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

@@ -1,10 +1,12 @@
-import { GraphEdge } from './graph.js';
+import { a as GraphEdge } from './graph-444E-DrF.js';
 import './capabilities.js';
-import './types-u2s9j1uD.js';
+import './types-CkiDUorT.js';
 import './message-parts/index.js';
 import './bounded-jsonl-state.js';
 import './operator-doctor-types.js';
 import './external-wiki-config.js';
+import './contradiction-config.js';
+import './graph-path-scoring-config.js';
 import './types-continuity.js';
 
 declare function graphEdgeKey(edge: GraphEdge): string;

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

@@ -1,10 +1,12 @@
-import { GraphEdge, GraphType } from './graph.js';
+import { a as GraphEdge, G as GraphType } from './graph-444E-DrF.js';
 import './capabilities.js';
-import './types-u2s9j1uD.js';
+import './types-CkiDUorT.js';
 import './message-parts/index.js';
 import './bounded-jsonl-state.js';
 import './operator-doctor-types.js';
 import './external-wiki-config.js';
+import './contradiction-config.js';
+import './graph-path-scoring-config.js';
 import './types-continuity.js';
 
 interface GraphSnapshotNode {

package/dist/{graph-edge-decay-Z6ENALU2.js → graph-edge-decay-65KMOJWY.js}

@@ -5,8 +5,9 @@ import {
   readGraphEdgeDecayStatus,
   runGraphEdgeDecayMaintenance,
   runGraphEdgeDecayMaintenanceAcrossNamespaces
-} from "./chunk-HNZKVLAN.js";
-import "./chunk-L2DPF4DF.js";
+} from "./chunk-S354QO4R.js";
+import "./chunk-BIJAWZYW.js";
+import "./chunk-LXY5VVGM.js";
 import "./chunk-2LSZVONP.js";
 import "./chunk-DEUNUKTD.js";
 import "./chunk-U3PN77QT.js";
@@ -19,4 +20,4 @@ export {
   runGraphEdgeDecayMaintenance,
   runGraphEdgeDecayMaintenanceAcrossNamespaces
 };
-//# sourceMappingURL=graph-edge-decay-Z6ENALU2.js.map
+//# sourceMappingURL=graph-edge-decay-65KMOJWY.js.map

package/dist/graph-edge-decay-65KMOJWY.js.map

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

package/dist/graph-edge-reinforcement.d.ts

@@ -1,10 +1,12 @@
-import { GraphEdge } from './graph.js';
+import { a as GraphEdge } from './graph-444E-DrF.js';
 import './capabilities.js';
-import './types-u2s9j1uD.js';
+import './types-CkiDUorT.js';
 import './message-parts/index.js';
 import './bounded-jsonl-state.js';
 import './operator-doctor-types.js';
 import './external-wiki-config.js';
+import './contradiction-config.js';
+import './graph-path-scoring-config.js';
 import './types-continuity.js';
 
 /**

package/dist/graph-path-reconstruction.d.ts

@@ -0,0 +1,10 @@
+export { d as ActivationPathCandidate, e as ActivationPathTracker, f as ActivationPredecessor, g as compareActivationPathCandidates, r as reconstructActivationPath } from './graph-444E-DrF.js';
+import './capabilities.js';
+import './types-CkiDUorT.js';
+import './message-parts/index.js';
+import './bounded-jsonl-state.js';
+import './operator-doctor-types.js';
+import './external-wiki-config.js';
+import './contradiction-config.js';
+import './graph-path-scoring-config.js';
+import './types-continuity.js';

package/dist/graph-path-reconstruction.js

@@ -0,0 +1,12 @@
+import {
+  ActivationPathTracker,
+  compareActivationPathCandidates,
+  reconstructActivationPath
+} from "./chunk-LXY5VVGM.js";
+import "./chunk-PZ5AY32C.js";
+export {
+  ActivationPathTracker,
+  compareActivationPathCandidates,
+  reconstructActivationPath
+};
+//# sourceMappingURL=graph-path-reconstruction.js.map

package/dist/graph-path-reconstruction.js.map

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

package/dist/graph-path-scoring-config.d.ts

@@ -0,0 +1,8 @@
+interface GraphPathScoringConfig {
+    enabled: boolean;
+    invalidNodePenalty: number;
+    includePathInProvenance: boolean;
+}
+declare function parseGraphPathScoringConfig(cfg: Record<string, unknown> | undefined): GraphPathScoringConfig;
+
+export { type GraphPathScoringConfig, parseGraphPathScoringConfig };

package/dist/graph-path-scoring-config.js

@@ -0,0 +1,10 @@
+import {
+  parseGraphPathScoringConfig
+} from "./chunk-6ZN34ISG.js";
+import "./chunk-PQVCH2AE.js";
+import "./chunk-3WCASNQZ.js";
+import "./chunk-PZ5AY32C.js";
+export {
+  parseGraphPathScoringConfig
+};
+//# sourceMappingURL=graph-path-scoring-config.js.map

package/dist/graph-path-scoring-config.js.map

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

package/dist/graph-path-scoring.d.ts

@@ -0,0 +1,36 @@
+import { A as ActivationPath } from './graph-444E-DrF.js';
+import { l as MemoryFrontmatter, y as MemoryStatus } from './types-CkiDUorT.js';
+import './capabilities.js';
+import './message-parts/index.js';
+import './bounded-jsonl-state.js';
+import './operator-doctor-types.js';
+import './external-wiki-config.js';
+import './contradiction-config.js';
+import './graph-path-scoring-config.js';
+import './types-continuity.js';
+
+/** Memory state used to score an intermediate path node. */
+interface PathNodeState extends Pick<MemoryFrontmatter, "valid_at" | "invalid_at" | "created" | "supersededAt" | "eventTimeSource"> {
+    id: string;
+    status: MemoryStatus | null;
+}
+/** Configuration for graph-path evidence scoring. */
+interface PathScoringOptions {
+    asOf: string;
+    invalidNodePenalty: number;
+}
+interface PathScoreDetail {
+    score: number;
+    pathPenaltyApplied: boolean;
+}
+declare function scoreEvidencePathDetail(evidencePath: ActivationPath | null, nodeStates: ReadonlyMap<string, PathNodeState>, options: PathScoringOptions): PathScoreDetail;
+/**
+ * Return the multiplicative evidence factor for one graph activation path.
+ *
+ * Edge confidence is multiplied for every hop. Invalid intermediate memories
+ * receive the configured penalty once each. Seed and candidate states do not
+ * affect the result because the caller already scored those memories.
+ */
+declare function scoreEvidencePath(evidencePath: ActivationPath | null, nodeStates: ReadonlyMap<string, PathNodeState>, options: PathScoringOptions): number;
+
+export { type PathNodeState, type PathScoreDetail, type PathScoringOptions, scoreEvidencePath, scoreEvidencePathDetail };

package/dist/graph-path-scoring.js

@@ -0,0 +1,11 @@
+import {
+  scoreEvidencePath,
+  scoreEvidencePathDetail
+} from "./chunk-XXSOVESA.js";
+import "./chunk-6CIAGZ6X.js";
+import "./chunk-PZ5AY32C.js";
+export {
+  scoreEvidencePath,
+  scoreEvidencePathDetail
+};
+//# sourceMappingURL=graph-path-scoring.js.map

package/dist/graph-path-scoring.js.map

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