@remnic/core 1.0.0

package/dist/behavior-learner.js

@@ -0,0 +1,124 @@
+import {
+  clampInstructionHeavyTokenCap
+} from "./chunk-6HZ6AO2P.js";
+import {
+  clamp01,
+  clampLifecycleThreshold
+} from "./chunk-QCCCQT3O.js";
+
+// src/behavior-learner.ts
+var TUNABLE_BEHAVIOR_PARAMETERS = [
+  "recencyWeight",
+  "lifecyclePromoteHeatThreshold",
+  "lifecycleStaleDecayThreshold",
+  "cronRecallInstructionHeavyTokenCap"
+];
+function clampToRange(parameter, value) {
+  switch (parameter) {
+    case "recencyWeight":
+      return clamp01(value);
+    case "lifecyclePromoteHeatThreshold":
+    case "lifecycleStaleDecayThreshold":
+      return clampLifecycleThreshold(value);
+    case "cronRecallInstructionHeavyTokenCap":
+      return clampInstructionHeavyTokenCap(value);
+  }
+}
+function currentValueFor(parameter, currentPolicy) {
+  return currentPolicy[parameter];
+}
+function maxDeltaFor(parameter, maxDeltaPerCycle) {
+  if (!Number.isFinite(maxDeltaPerCycle) || maxDeltaPerCycle <= 0) return 0;
+  if (parameter === "cronRecallInstructionHeavyTokenCap") {
+    return Math.max(1, Math.round(maxDeltaPerCycle * 40));
+  }
+  return maxDeltaPerCycle;
+}
+function confidenceFromSignals(signalCount, pressureMagnitude) {
+  if (signalCount <= 0) return 0;
+  return clamp01(pressureMagnitude * Math.min(1, signalCount / 20));
+}
+function aggregateSignalPressure(signals) {
+  if (signals.length === 0) return 0;
+  let net = 0;
+  for (const signal of signals) {
+    const weight = clamp01(signal.confidence);
+    if (signal.direction === "positive") net += weight;
+    if (signal.direction === "negative") net -= weight;
+  }
+  return Math.max(-1, Math.min(1, net / signals.length));
+}
+function selectRecentSignals(input) {
+  if (input.learningWindowDays <= 0) return [...input.signals];
+  const nowMs = (input.now ?? /* @__PURE__ */ new Date()).getTime();
+  const minTs = nowMs - input.learningWindowDays * 864e5;
+  return input.signals.filter((signal) => {
+    const ts = Date.parse(signal.timestamp);
+    if (!Number.isFinite(ts)) return false;
+    return ts >= minTs;
+  });
+}
+function parameterDirection(parameter, pressure) {
+  switch (parameter) {
+    case "recencyWeight":
+      return pressure;
+    case "lifecyclePromoteHeatThreshold":
+      return pressure * -0.5;
+    case "lifecycleStaleDecayThreshold":
+      return pressure * 0.5;
+    case "cronRecallInstructionHeavyTokenCap":
+      return pressure * 0.75;
+  }
+}
+function learnBehaviorPolicyAdjustments(input) {
+  const nowIso = (input.now ?? /* @__PURE__ */ new Date()).toISOString();
+  const windowedSignals = selectRecentSignals(input);
+  if (windowedSignals.length < input.minSignalCount) {
+    return {
+      version: 1,
+      windowDays: input.learningWindowDays,
+      minSignalCount: input.minSignalCount,
+      maxDeltaPerCycle: input.maxDeltaPerCycle,
+      protectedParams: [...input.protectedParams],
+      adjustments: [],
+      updatedAt: nowIso
+    };
+  }
+  const pressure = aggregateSignalPressure(windowedSignals);
+  const adjustments = [];
+  for (const parameter of TUNABLE_BEHAVIOR_PARAMETERS) {
+    if (input.protectedParams.includes(parameter)) continue;
+    const currentValue = currentValueFor(parameter, input.currentPolicy);
+    const direction = parameterDirection(parameter, pressure);
+    const deltaBound = maxDeltaFor(parameter, input.maxDeltaPerCycle);
+    const proposedDelta = Math.max(-deltaBound, Math.min(deltaBound, direction * deltaBound));
+    if (Math.abs(proposedDelta) <= 0) continue;
+    const nextValue = clampToRange(parameter, currentValue + proposedDelta);
+    const roundedDelta = nextValue - currentValue;
+    if (Math.abs(roundedDelta) <= Number.EPSILON) continue;
+    adjustments.push({
+      parameter,
+      previousValue: currentValue,
+      nextValue,
+      delta: roundedDelta,
+      evidenceCount: windowedSignals.length,
+      confidence: confidenceFromSignals(windowedSignals.length, Math.abs(pressure)),
+      reason: `signal_pressure=${pressure.toFixed(3)} evidence=${windowedSignals.length}`,
+      appliedAt: nowIso
+    });
+  }
+  return {
+    version: 1,
+    windowDays: input.learningWindowDays,
+    minSignalCount: input.minSignalCount,
+    maxDeltaPerCycle: input.maxDeltaPerCycle,
+    protectedParams: [...input.protectedParams],
+    adjustments,
+    updatedAt: nowIso
+  };
+}
+export {
+  TUNABLE_BEHAVIOR_PARAMETERS,
+  learnBehaviorPolicyAdjustments
+};
+//# sourceMappingURL=behavior-learner.js.map

package/dist/behavior-learner.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/behavior-learner.ts"],"sourcesContent":["import { clamp01, clampLifecycleThreshold } from \"./lifecycle.js\";\nimport { clampInstructionHeavyTokenCap } from \"./recall-query-policy.js\";\nimport type { BehaviorLoopAdjustment, BehaviorLoopPolicyState, BehaviorSignalEvent, PluginConfig } from \"./types.js\";\n\nexport const TUNABLE_BEHAVIOR_PARAMETERS = [\n  \"recencyWeight\",\n  \"lifecyclePromoteHeatThreshold\",\n  \"lifecycleStaleDecayThreshold\",\n  \"cronRecallInstructionHeavyTokenCap\",\n] as const;\n\nexport type TunableBehaviorParameter = (typeof TUNABLE_BEHAVIOR_PARAMETERS)[number];\n\nexport interface BehaviorLearnerInput {\n  signals: BehaviorSignalEvent[];\n  now?: Date;\n  learningWindowDays: number;\n  minSignalCount: number;\n  maxDeltaPerCycle: number;\n  protectedParams: string[];\n  currentPolicy: Pick<\n    PluginConfig,\n    \"recencyWeight\" | \"lifecyclePromoteHeatThreshold\" | \"lifecycleStaleDecayThreshold\" | \"cronRecallInstructionHeavyTokenCap\"\n  >;\n}\n\nfunction clampToRange(parameter: TunableBehaviorParameter, value: number): number {\n  switch (parameter) {\n    case \"recencyWeight\":\n      return clamp01(value);\n    case \"lifecyclePromoteHeatThreshold\":\n    case \"lifecycleStaleDecayThreshold\":\n      return clampLifecycleThreshold(value);\n    case \"cronRecallInstructionHeavyTokenCap\":\n      return clampInstructionHeavyTokenCap(value);\n  }\n}\n\nfunction currentValueFor(\n  parameter: TunableBehaviorParameter,\n  currentPolicy: BehaviorLearnerInput[\"currentPolicy\"],\n): number {\n  return currentPolicy[parameter];\n}\n\nfunction maxDeltaFor(parameter: TunableBehaviorParameter, maxDeltaPerCycle: number): number {\n  if (!Number.isFinite(maxDeltaPerCycle) || maxDeltaPerCycle <= 0) return 0;\n  if (parameter === \"cronRecallInstructionHeavyTokenCap\") {\n    return Math.max(1, Math.round(maxDeltaPerCycle * 40));\n  }\n  return maxDeltaPerCycle;\n}\n\nfunction confidenceFromSignals(signalCount: number, pressureMagnitude: number): number {\n  if (signalCount <= 0) return 0;\n  return clamp01(pressureMagnitude * Math.min(1, signalCount / 20));\n}\n\nfunction aggregateSignalPressure(signals: BehaviorSignalEvent[]): number {\n  if (signals.length === 0) return 0;\n  let net = 0;\n  for (const signal of signals) {\n    const weight = clamp01(signal.confidence);\n    if (signal.direction === \"positive\") net += weight;\n    if (signal.direction === \"negative\") net -= weight;\n  }\n  return Math.max(-1, Math.min(1, net / signals.length));\n}\n\nfunction selectRecentSignals(input: BehaviorLearnerInput): BehaviorSignalEvent[] {\n  if (input.learningWindowDays <= 0) return [...input.signals];\n  const nowMs = (input.now ?? new Date()).getTime();\n  const minTs = nowMs - input.learningWindowDays * 86_400_000;\n  return input.signals.filter((signal) => {\n    const ts = Date.parse(signal.timestamp);\n    if (!Number.isFinite(ts)) return false;\n    return ts >= minTs;\n  });\n}\n\nfunction parameterDirection(parameter: TunableBehaviorParameter, pressure: number): number {\n  switch (parameter) {\n    case \"recencyWeight\":\n      return pressure;\n    case \"lifecyclePromoteHeatThreshold\":\n      return pressure * -0.5;\n    case \"lifecycleStaleDecayThreshold\":\n      return pressure * 0.5;\n    case \"cronRecallInstructionHeavyTokenCap\":\n      return pressure * 0.75;\n  }\n}\n\nexport function learnBehaviorPolicyAdjustments(input: BehaviorLearnerInput): BehaviorLoopPolicyState {\n  const nowIso = (input.now ?? new Date()).toISOString();\n  const windowedSignals = selectRecentSignals(input);\n  if (windowedSignals.length < input.minSignalCount) {\n    return {\n      version: 1,\n      windowDays: input.learningWindowDays,\n      minSignalCount: input.minSignalCount,\n      maxDeltaPerCycle: input.maxDeltaPerCycle,\n      protectedParams: [...input.protectedParams],\n      adjustments: [],\n      updatedAt: nowIso,\n    };\n  }\n\n  const pressure = aggregateSignalPressure(windowedSignals);\n  const adjustments: BehaviorLoopAdjustment[] = [];\n  for (const parameter of TUNABLE_BEHAVIOR_PARAMETERS) {\n    if (input.protectedParams.includes(parameter)) continue;\n    const currentValue = currentValueFor(parameter, input.currentPolicy);\n    const direction = parameterDirection(parameter, pressure);\n    const deltaBound = maxDeltaFor(parameter, input.maxDeltaPerCycle);\n    const proposedDelta = Math.max(-deltaBound, Math.min(deltaBound, direction * deltaBound));\n    if (Math.abs(proposedDelta) <= 0) continue;\n\n    const nextValue = clampToRange(parameter, currentValue + proposedDelta);\n    const roundedDelta = nextValue - currentValue;\n    if (Math.abs(roundedDelta) <= Number.EPSILON) continue;\n\n    adjustments.push({\n      parameter,\n      previousValue: currentValue,\n      nextValue,\n      delta: roundedDelta,\n      evidenceCount: windowedSignals.length,\n      confidence: confidenceFromSignals(windowedSignals.length, Math.abs(pressure)),\n      reason: `signal_pressure=${pressure.toFixed(3)} evidence=${windowedSignals.length}`,\n      appliedAt: nowIso,\n    });\n  }\n\n  return {\n    version: 1,\n    windowDays: input.learningWindowDays,\n    minSignalCount: input.minSignalCount,\n    maxDeltaPerCycle: input.maxDeltaPerCycle,\n    protectedParams: [...input.protectedParams],\n    adjustments,\n    updatedAt: nowIso,\n  };\n}\n"],"mappings":"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","names":[]}

package/dist/behavior-signals.d.ts

@@ -0,0 +1,15 @@
+import { MemoryCategory, BehaviorSignalEvent } from './types.js';
+
+declare function buildBehaviorSignalHash(category: MemoryCategory, content: string): string;
+declare function buildBehaviorSignalsForMemory(input: {
+    memoryId: string;
+    category: MemoryCategory;
+    content: string;
+    namespace: string;
+    confidence: number;
+    timestamp?: string;
+    source?: "extraction" | "correction";
+}): BehaviorSignalEvent[];
+declare function dedupeBehaviorSignalsByMemoryAndHash(signals: BehaviorSignalEvent[]): BehaviorSignalEvent[];
+
+export { buildBehaviorSignalHash, buildBehaviorSignalsForMemory, dedupeBehaviorSignalsByMemoryAndHash };

package/dist/behavior-signals.js

@@ -0,0 +1,11 @@
+import {
+  buildBehaviorSignalHash,
+  buildBehaviorSignalsForMemory,
+  dedupeBehaviorSignalsByMemoryAndHash
+} from "./chunk-JWPLJLDU.js";
+export {
+  buildBehaviorSignalHash,
+  buildBehaviorSignalsForMemory,
+  dedupeBehaviorSignalsByMemoryAndHash
+};
+//# sourceMappingURL=behavior-signals.js.map

package/dist/behavior-signals.js.map

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

package/dist/bootstrap.d.ts

@@ -0,0 +1,46 @@
+import { PluginConfig } from './types.js';
+import { O as Orchestrator } from './orchestrator-zTa-Qo-1.js';
+import './buffer.js';
+import './storage.js';
+import './memory-projection-store-NxMkbocT.js';
+import 'better-sqlite3';
+import './port-C1GZFv8h.js';
+import './transcript.js';
+import './session-integrity.js';
+import './summarizer.js';
+import './model-registry.js';
+import './local-llm.js';
+import './relevance.js';
+import './negative.js';
+import './recall-state.js';
+import './session-observer-state.js';
+import './embedding-fallback.js';
+import './semantic-consolidation.js';
+import 'zod';
+import './policy-runtime.js';
+import './profiling.js';
+
+type BootstrapResult = {
+    sessionsScanned: number;
+    turnsProcessed: number;
+    highSignalTurns: number;
+    memoriesCreated: number;
+    skipped: number;
+};
+type BootstrapOptions = {
+    dryRun?: boolean;
+    sessionsDir?: string;
+    limit?: number;
+    since?: Date;
+};
+declare class BootstrapEngine {
+    private config;
+    private orchestrator;
+    constructor(config: PluginConfig, orchestrator: Orchestrator);
+    run(options: BootstrapOptions): Promise<BootstrapResult>;
+    private resolveSessions;
+    private readSessionsFromDir;
+    private listJsonlFiles;
+}
+
+export { BootstrapEngine, type BootstrapOptions, type BootstrapResult };

package/dist/bootstrap.js

@@ -0,0 +1,9 @@
+import {
+  BootstrapEngine
+} from "./chunk-YNI4S5WT.js";
+import "./chunk-XYIK4LF6.js";
+import "./chunk-KWBU5S5U.js";
+export {
+  BootstrapEngine
+};
+//# sourceMappingURL=bootstrap.js.map

package/dist/bootstrap.js.map

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

package/dist/boxes.d.ts

@@ -0,0 +1,93 @@
+/**
+ * Memory Boxes + Trace Weaving (v8.0 Phase 2A)
+ *
+ * Implements the Membox concept: a sliding topic window that forms an "open box"
+ * accumulating related memories. The box is sealed on topic shift or time gap,
+ * then written to memory/boxes/YYYY-MM-DD/box-<id>.md.
+ *
+ * Trace Weaving links recurring topic boxes with a shared traceId so that
+ * cross-session continuity on the same topics is preserved and discoverable.
+ */
+declare const BOX_DIR = "boxes";
+interface BoxFrontmatter {
+    id: string;
+    memoryKind: "box";
+    createdAt: string;
+    sealedAt: string;
+    sealReason: SealReason;
+    sessionKey?: string;
+    topics: string[];
+    memoryIds: string[];
+    traceId?: string;
+    /** High-level task goal for this episode (REMem-inspired). */
+    goal?: string;
+    /** Tools invoked during this episode. */
+    toolsUsed?: string[];
+    /** Episode outcome: success, failure, partial, or unknown. */
+    outcome?: "success" | "failure" | "partial" | "unknown";
+}
+type SealReason = "topic_shift" | "time_gap" | "max_memories" | "forced" | "flush";
+interface BoxBuilderConfig {
+    memoryBoxesEnabled: boolean;
+    traceWeaverEnabled: boolean;
+    /** Jaccard threshold below which topic shift triggers seal (0-1, default 0.35) */
+    boxTopicShiftThreshold: number;
+    /** Time gap in ms before sealing an open box (default 30 min) */
+    boxTimeGapMs: number;
+    /** Max memories in one box before forced seal */
+    boxMaxMemories: number;
+    /** Days back to look for trace links */
+    traceWeaverLookbackDays: number;
+    /** Minimum topic overlap to assign same traceId (0-1, default 0.4) */
+    traceWeaverOverlapThreshold: number;
+}
+interface ExtractionEvent {
+    topics: string[];
+    memoryIds: string[];
+    timestamp: string;
+    goal?: string;
+    toolsUsed?: string[];
+}
+/**
+ * Jaccard similarity between two topic arrays.
+ * Returns 0.0 for empty inputs.
+ */
+declare function topicOverlapScore(a: string[], b: string[]): number;
+declare function parseBoxFrontmatter(raw: string): BoxFrontmatter | null;
+declare class BoxBuilder {
+    private baseDir;
+    private cfg;
+    private openBox;
+    private stateLoaded;
+    constructor(baseDir: string, cfg: BoxBuilderConfig);
+    private get boxBaseDir();
+    private get stateDir();
+    private get openBoxStatePath();
+    private get tracesPath();
+    private loadOpenBox;
+    private saveOpenBox;
+    private loadTraceIndex;
+    private saveTraceIndex;
+    /**
+     * Called after each extraction run.
+     * Decides whether to seal the current open box and/or start a new one.
+     */
+    onExtraction(event: ExtractionEvent): Promise<void>;
+    private newBox;
+    /**
+     * Seal the current open box and write it to disk.
+     * Also runs trace weaving if enabled.
+     */
+    sealCurrent(reason: SealReason): Promise<string | null>;
+    /**
+     * Find an existing trace that matches box topics, or create a new trace.
+     * Returns the traceId to assign to this box.
+     */
+    private resolveTrace;
+    /**
+     * Read all sealed boxes from the last N days for recall injection.
+     */
+    readRecentBoxes(days: number): Promise<BoxFrontmatter[]>;
+}
+
+export { BOX_DIR, BoxBuilder, type BoxBuilderConfig, type BoxFrontmatter, type SealReason, parseBoxFrontmatter, topicOverlapScore };

package/dist/boxes.js

@@ -0,0 +1,14 @@
+import {
+  BOX_DIR,
+  BoxBuilder,
+  parseBoxFrontmatter,
+  topicOverlapScore
+} from "./chunk-M5KEYE5E.js";
+import "./chunk-KWBU5S5U.js";
+export {
+  BOX_DIR,
+  BoxBuilder,
+  parseBoxFrontmatter,
+  topicOverlapScore
+};
+//# sourceMappingURL=boxes.js.map

package/dist/boxes.js.map

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

package/dist/buffer.d.ts

@@ -0,0 +1,22 @@
+import { StorageManager } from './storage.js';
+import { PluginConfig, BufferTurn } from './types.js';
+import './memory-projection-store-NxMkbocT.js';
+import 'better-sqlite3';
+
+type TriggerDecision = "extract_now" | "extract_batch" | "keep_buffering";
+declare class SmartBuffer {
+    private readonly config;
+    private readonly storage;
+    private state;
+    private loaded;
+    constructor(config: PluginConfig, storage: StorageManager);
+    load(): Promise<void>;
+    save(): Promise<void>;
+    addTurn(turn: BufferTurn): Promise<TriggerDecision>;
+    private evaluate;
+    getTurns(): BufferTurn[];
+    clearAfterExtraction(): Promise<void>;
+    getExtractionCount(): number;
+}
+
+export { SmartBuffer, type TriggerDecision };

package/dist/buffer.js

@@ -0,0 +1,9 @@
+import {
+  SmartBuffer
+} from "./chunk-DORBM6OB.js";
+import "./chunk-XYIK4LF6.js";
+import "./chunk-KWBU5S5U.js";
+export {
+  SmartBuffer
+};
+//# sourceMappingURL=buffer.js.map

package/dist/buffer.js.map

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

package/dist/calibration.d.ts

@@ -0,0 +1,81 @@
+import { FallbackLlmClient } from './fallback-llm.js';
+import { GatewayConfig } from './types.js';
+
+/**
+ * calibration.ts — Prediction-Error-Driven Model-User Calibration
+ *
+ * Analyzes patterns in user corrections to identify systematic miscalibration
+ * between the model's predictions and the user's actual expectations.
+ * During consolidation, replays chains of similar corrections through an LLM
+ * to synthesize CalibrationRules that adjust model behavior for this specific user.
+ *
+ * Inspired by:
+ * - Cerebellar motor calibration (prediction errors drive lasting adjustments)
+ * - Temporal difference learning (dopamine signals prediction error)
+ * - Tesla FSD shadow mode (divergence between prediction and reality = training signal)
+ */
+
+interface CalibrationRule {
+    id: string;
+    ruleType: "model_tendency" | "user_expectation" | "scope_boundary" | "verification_required";
+    condition: string;
+    modelTendency: string;
+    userExpectation: string;
+    calibration: string;
+    confidence: number;
+    evidenceCount: number;
+    evidenceCorrectionIds: string[];
+    createdAt: string;
+    lastReinforcedAt: string;
+}
+interface CalibrationIndex {
+    rules: CalibrationRule[];
+    updatedAt: string;
+    totalCorrectionsAnalyzed: number;
+}
+declare function readCalibrationIndex(memoryDir: string): Promise<CalibrationIndex>;
+interface CorrectionMemory {
+    id: string;
+    content: string;
+    created: string;
+    confidence: number;
+    entityRefs: string[];
+    tags: string[];
+}
+declare function synthesizeCalibrationRules(corrections: CorrectionMemory[], llm: FallbackLlmClient, existingRules: CalibrationRule[], agentId?: string): Promise<CalibrationRule[]>;
+/**
+ * Build a recall section from calibration rules relevant to the current query.
+ * Uses the LLM to select which rules apply to the current context.
+ */
+declare function buildCalibrationRecallSection(rules: CalibrationRule[], query: string, maxChars?: number): string | null;
+/**
+ * Run the full calibration pipeline:
+ * 1. Read all corrections
+ * 2. Send to LLM for clustering and rule synthesis
+ * 3. Merge with existing rules
+ * 4. Write updated index
+ */
+declare function runCalibrationConsolidation(options: {
+    memoryDir: string;
+    gatewayConfig?: GatewayConfig;
+    gatewayAgentId?: string;
+}): Promise<CalibrationRule[]>;
+/**
+ * Standalone entry point for calibration consolidation that can be called
+ * independently of weekly compounding. The compounding engine's
+ * `synthesizeWeekly()` is one trigger, but orchestrators or periodic
+ * maintenance jobs should call this directly so calibration is not gated
+ * on weekly compounding being enabled.
+ */
+declare function runCalibrationIfEnabled(options: {
+    memoryDir: string;
+    calibrationEnabled: boolean;
+    gatewayConfig?: GatewayConfig;
+}): Promise<CalibrationRule[]>;
+/**
+ * Get calibration rules for recall injection.
+ * Reads the pre-computed calibration index.
+ */
+declare function getCalibrationRulesForRecall(memoryDir: string): Promise<CalibrationRule[]>;
+
+export { type CalibrationIndex, type CalibrationRule, buildCalibrationRecallSection, getCalibrationRulesForRecall, readCalibrationIndex, runCalibrationConsolidation, runCalibrationIfEnabled, synthesizeCalibrationRules };