@remnic/core 1.1.3 → 1.1.5

package/dist/{chunk-DR7MCMPS.js → chunk-DTDB6YS2.js}

@@ -11,7 +11,7 @@ import {
 } from "./chunk-H7XKCNR6.js";
 import {
   toRecallExplainJson
-} from "./chunk-LW2NMHDW.js";
+} from "./chunk-Y6EPN6XF.js";
 import {
   clusterByKey,
   resolveGitContext
@@ -27,7 +27,7 @@ import {
 } from "./chunk-EQINRHYR.js";
 import {
   estimateRecallTokens
-} from "./chunk-USFPPRAF.js";
+} from "./chunk-WMK6YP7C.js";
 import {
   buildProposedActions,
   buildQualityScore,
@@ -35,7 +35,7 @@ import {
   listMemoryGovernanceRuns,
   readMemoryGovernanceRunArtifact,
   runMemoryGovernance
-} from "./chunk-LZRYQK6L.js";
+} from "./chunk-3YBRSJ52.js";
 import {
   recordMemoryOutcome
 } from "./chunk-EIR5VLIH.js";
@@ -50,6 +50,9 @@ import {
 import {
   wrapWorkLayerContext
 } from "./chunk-EEQLFRUM.js";
+import {
+  formatProfileTraceAscii
+} from "./chunk-NBNN5GOB.js";
 import {
   buildProcedurePersistBody,
   normalizeProcedureSteps
@@ -76,14 +79,14 @@ import {
   buildBriefing,
   parseBriefingFocus,
   parseBriefingWindow
-} from "./chunk-SS253RXF.js";
+} from "./chunk-KCZZLFW5.js";
 import {
   parseEntityFile
-} from "./chunk-DCE6SQLA.js";
+} from "./chunk-46AIFPQM.js";
 import {
   DEFAULT_RECALL_DISCLOSURE,
   isRecallDisclosure
-} from "./chunk-43EKP2UK.js";
+} from "./chunk-TOC3VOOF.js";
 import {
   inferMemoryStatus,
   toMemoryPathRel
@@ -94,7 +97,7 @@ import {
 } from "./chunk-SCU65EZI.js";
 import {
   getMemoryProjectionPath
-} from "./chunk-BOUYNNYD.js";
+} from "./chunk-67YLUWLG.js";
 import {
   log
 } from "./chunk-2ODBA7MQ.js";
@@ -113,6 +116,7 @@ import {
 import { stat } from "fs/promises";
 import * as nodeFs from "fs/promises";
 import { constants as fsConstants } from "fs";
+import { createHash } from "crypto";
 import { ZodError } from "zod";
 
 // src/work/storage.ts
@@ -2553,6 +2557,147 @@ var EngramAccessService = class {
     });
     return { namespace: resolvedNamespace, ...report };
   }
+  async memorySummarizeHourly() {
+    await this.orchestrator.summarizer.runHourly();
+    return {
+      ok: true,
+      message: "Hourly summarization completed. Check the summaries directory for results."
+    };
+  }
+  async conversationIndexUpdate(request = {}) {
+    if (!this.orchestrator.config.conversationIndexEnabled) {
+      return {
+        enabled: false,
+        sessions: 0,
+        chunks: 0,
+        skipped: 0,
+        skippedSessionKeys: [],
+        embeddedRuns: 0,
+        reason: "disabled"
+      };
+    }
+    const hours = typeof request.hours === "number" && Number.isFinite(request.hours) ? Math.max(1, Math.floor(request.hours)) : 24;
+    let sessionKey;
+    if (request.sessionKey !== void 0) {
+      if (typeof request.sessionKey !== "string" || request.sessionKey.trim().length === 0) {
+        throw new EngramAccessInputError("sessionKey must be a non-empty string when provided");
+      }
+      sessionKey = request.sessionKey.trim();
+    }
+    if (sessionKey) {
+      const result = await this.orchestrator.updateConversationIndex(
+        sessionKey,
+        hours,
+        { embed: request.embed }
+      );
+      return {
+        enabled: true,
+        sessionKey,
+        sessions: 1,
+        chunks: result.chunks,
+        skipped: result.skipped ? 1 : 0,
+        skippedSessionKeys: result.skipped ? [sessionKey] : [],
+        embeddedRuns: result.embedded ? 1 : 0,
+        reason: result.reason,
+        retryAfterMs: result.retryAfterMs
+      };
+    }
+    const sessionKeys = await this.orchestrator.transcript.listSessionKeys();
+    let chunks = 0;
+    let skipped = 0;
+    const skippedSessionKeys = [];
+    let embeddedRuns = 0;
+    for (const sessionKey2 of sessionKeys) {
+      const result = await this.orchestrator.updateConversationIndex(
+        sessionKey2,
+        hours,
+        { embed: request.embed }
+      );
+      chunks += result.chunks;
+      if (result.skipped) {
+        skipped += 1;
+        skippedSessionKeys.push(sessionKey2);
+      }
+      if (result.embedded) {
+        embeddedRuns += 1;
+      }
+    }
+    return {
+      enabled: true,
+      sessions: sessionKeys.length,
+      chunks,
+      skipped,
+      skippedSessionKeys,
+      embeddedRuns
+    };
+  }
+  async profilingReport(request = {}) {
+    const profiler = this.orchestrator.profiler;
+    if (!profiler.isEnabled) {
+      return {
+        enabled: false,
+        reason: "disabled",
+        message: "Profiling is disabled. Set profilingEnabled: true in your plugin config to enable."
+      };
+    }
+    const format = request.format ?? "ascii";
+    if (format !== "ascii" && format !== "json") {
+      throw new EngramAccessInputError("format must be one of: ascii, json");
+    }
+    const limit = request.limit ?? 5;
+    if (!Number.isInteger(limit) || limit < 1 || limit > 20) {
+      throw new EngramAccessInputError("limit must be an integer between 1 and 20");
+    }
+    const traces = profiler.getRecentTraces(limit);
+    const stats = profiler.getStats();
+    const bottleneck = profiler.identifyBottleneck();
+    if (format === "json") {
+      return {
+        enabled: true,
+        format,
+        traces,
+        stats,
+        bottleneck
+      };
+    }
+    const lines = [];
+    lines.push("Engram Profiling Report");
+    lines.push("=".repeat(60));
+    lines.push("");
+    const allBuckets = [
+      ["byKind", stats.byKind],
+      ["bySpan", stats.bySpan]
+    ];
+    const hasStats = allBuckets.some(([, entries]) => Object.keys(entries).length > 0);
+    if (hasStats) {
+      lines.push("Aggregate Stats (all retained traces):");
+      for (const [bucket, entries] of allBuckets) {
+        for (const [key, summary] of Object.entries(entries)) {
+          lines.push(
+            `  ${bucket}/${key}: avg=${summary.avgMs}ms p50=${summary.p50Ms}ms p95=${summary.p95Ms}ms max=${summary.maxMs}ms (n=${summary.count})`
+          );
+        }
+      }
+      lines.push("");
+    }
+    if (bottleneck) {
+      lines.push(`Bottleneck: ${bottleneck}`);
+      lines.push("");
+    }
+    if (traces.length === 0) {
+      lines.push("No traces recorded yet. Trigger a recall or extraction to see timing data.");
+    } else {
+      for (const trace of traces) {
+        lines.push(formatProfileTraceAscii(trace));
+        lines.push("");
+      }
+    }
+    return {
+      enabled: true,
+      format,
+      report: lines.join("\n")
+    };
+  }
   async trustZoneStatus(namespace, principal) {
     const resolvedNamespace = this.resolveReadableNamespace(namespace, principal);
     const storage = await this.orchestrator.getStorage(resolvedNamespace);
@@ -2770,10 +2915,15 @@ var EngramAccessService = class {
         sessionKey: lcmSessionKey,
         role: m.role,
         content: m.content,
+        parts: m.parts,
+        rawContent: m.rawContent,
+        sourceFormat: m.sourceFormat,
         timestamp: (/* @__PURE__ */ new Date()).toISOString()
       }));
       try {
-        const extractionPromise = this.orchestrator.ingestReplayBatch(turns);
+        const extractionPromise = this.orchestrator.ingestReplayBatch(turns, {
+          archiveLcm: false
+        });
         extractionPromise.catch((err) => {
           log.error(`access-observe background extraction failed: ${err}`);
         });
@@ -3472,6 +3622,66 @@ ${next}`);
     });
     return { promoted: true, memoryId: request.memoryId };
   }
+  async memoryActionApply(request) {
+    const actionTypes = /* @__PURE__ */ new Set([
+      "store_episode",
+      "store_note",
+      "update_note",
+      "create_artifact",
+      "summarize_node",
+      "discard",
+      "link_graph"
+    ]);
+    if (!actionTypes.has(request.action)) {
+      throw new EngramAccessInputError(
+        `memory_action_apply: invalid action ${JSON.stringify(request.action)}`
+      );
+    }
+    if (this.orchestrator.config.contextCompressionActionsEnabled !== true) {
+      throw new EngramAccessInputError(
+        "memory_action_apply is disabled; enable contextCompressionActionsEnabled to use this tool"
+      );
+    }
+    const outcome = request.outcome ?? "skipped";
+    if (outcome !== "applied" && outcome !== "skipped" && outcome !== "failed") {
+      throw new EngramAccessInputError(
+        `memory_action_apply: outcome must be "applied", "skipped", or "failed"; got ${JSON.stringify(outcome)}`
+      );
+    }
+    const resolvedNs = this.resolveWritableNamespace(
+      request.namespace,
+      request.sessionKey,
+      request.principal
+    );
+    const inputSummaryParts = [
+      request.content,
+      request.category ? `category=${request.category}` : void 0,
+      request.linkTargetId ? `linkTargetId=${request.linkTargetId}` : void 0,
+      request.linkType ? `linkType=${request.linkType}` : void 0,
+      typeof request.linkStrength === "number" ? `linkStrength=${request.linkStrength}` : void 0,
+      request.artifactType ? `artifactType=${request.artifactType}` : void 0,
+      typeof request.execute === "boolean" ? `execute=${request.execute}` : void 0
+    ].filter((part) => typeof part === "string" && part.length > 0);
+    const event = {
+      action: request.action,
+      outcome,
+      namespace: resolvedNs,
+      actor: "access.memory_action_apply",
+      subsystem: "access.memory_action_apply",
+      reason: request.reason,
+      memoryId: request.memoryId,
+      sourceSessionKey: request.sessionKey,
+      inputSummary: inputSummaryParts.length > 0 ? inputSummaryParts.join(" | ").slice(0, 500) : void 0,
+      dryRun: request.dryRun === true,
+      promptHash: typeof request.sourcePrompt === "string" && request.sourcePrompt.length > 0 ? createHash("sha256").update(request.sourcePrompt).digest("hex") : void 0
+    };
+    const preview = this.orchestrator.previewMemoryActionEvent(event);
+    if (request.dryRun === true) {
+      return { recorded: false, dryRun: true, event: preview };
+    }
+    const recorded = await this.orchestrator.appendMemoryActionEvent(event);
+    return { recorded, event: preview };
+  }
   async contextCheckpoint(request) {
     const resolvedNs = this.resolveWritableNamespace(request.namespace, request.sessionKey, request.principal);
     const storage = await this.orchestrator.getStorage(resolvedNs);
@@ -4017,4 +4227,4 @@ export {
   shapeMemorySummary,
   EngramAccessService
 };
-//# sourceMappingURL=chunk-DR7MCMPS.js.map
+//# sourceMappingURL=chunk-DTDB6YS2.js.map