@remnic/core 1.0.2 → 1.0.3

package/dist/access-schema.js

@@ -11,7 +11,7 @@ import {
   trustZoneDemoSeedRequestSchema,
   trustZonePromoteRequestSchema,
   validateRequest
-} from "./chunk-PGK3VUHN.js";
+} from "./chunk-MTLYEMJB.js";
 export {
   daySummaryRequestSchema,
   formatZodError,

package/dist/access-service.d.ts

@@ -1,12 +1,13 @@
 import { DaySummaryResult, RecallPlanMode, MemoryFile, MemoryLifecycleEvent, EntityFile, MemoryStatus } from './types.js';
 import { ExplicitCaptureInput } from './explicit-capture.js';
-import { r as readMemoryGovernanceRunArtifact } from './memory-projection-store-NxMkbocT.js';
+import { r as readMemoryGovernanceRunArtifact } from './memory-projection-store-DeSXPh1j.js';
 import { LastRecallSnapshot } from './recall-state.js';
-import { O as Orchestrator, I as IntentDebugSnapshot, G as GraphRecallSnapshot } from './orchestrator-zTa-Qo-1.js';
+import { O as Orchestrator, I as IntentDebugSnapshot, G as GraphRecallSnapshot } from './orchestrator-B9kwlCep.js';
 import { TrustZoneStoreStatus, TrustZoneName, TrustZoneRecordKind, TrustZoneSourceClass, TrustZoneProvenanceScore, TrustZonePromotionResult, TrustZoneDemoSeedResult } from './trust-zones.js';
 import 'better-sqlite3';
 import './buffer.js';
 import './storage.js';
+import './page-versioning.js';
 import './port-C1GZFv8h.js';
 import './transcript.js';
 import './session-integrity.js';
@@ -17,7 +18,9 @@ import './relevance.js';
 import './negative.js';
 import './session-observer-state.js';
 import './embedding-fallback.js';
-import './semantic-consolidation.js';
+import './semantic-consolidation-DrvSYRdB.js';
+import './codex-materialize-CQlLTzke.js';
+import './logger.js';
 import 'zod';
 import './policy-runtime.js';
 import './profiling.js';
@@ -79,6 +82,28 @@ interface EngramAccessDaySummaryRequest {
     sessionKey?: string;
     namespace?: string;
 }
+/** Inputs accepted by the `remnic_briefing` MCP tool. */
+interface EngramAccessBriefingRequest {
+    since?: string;
+    focus?: string;
+    namespace?: string;
+    format?: "markdown" | "json";
+    maxFollowups?: number;
+    /** Caller principal for namespace access checks. Transport-bound — never from untrusted payloads. */
+    principal?: string;
+}
+/** Response for `remnic_briefing`. */
+interface EngramAccessBriefingResponse {
+    format: "markdown" | "json";
+    window: {
+        from: string;
+        to: string;
+    };
+    namespace: string;
+    markdown: string;
+    json: Record<string, unknown>;
+    followupsUnavailableReason?: string;
+}
 interface EngramAccessMemoryRecord {
     id: string;
     path: string;
@@ -349,6 +374,7 @@ declare class EngramAccessService {
     private readonly idempotency;
     private readonly idempotencyLocks;
     constructor(orchestrator: Orchestrator);
+    get briefingEnabled(): boolean;
     private resolveNamespace;
     private normalizeRecallMode;
     private resolveRecallNamespace;
@@ -362,6 +388,11 @@ declare class EngramAccessService {
     private withIdempotencyLock;
     health(namespace?: string): Promise<EngramAccessHealthResponse>;
     daySummary(request: EngramAccessDaySummaryRequest): Promise<DaySummaryResult | null>;
+    /**
+     * Build a daily context briefing. Gracefully degrades when the OpenAI key
+     * or Responses API is unavailable — never throws for LLM-related problems.
+     */
+    briefing(request: EngramAccessBriefingRequest): Promise<EngramAccessBriefingResponse>;
     recall(request: EngramAccessRecallRequest): Promise<EngramAccessRecallResponse>;
     recallExplain(request?: EngramAccessRecallExplainRequest): Promise<EngramAccessRecallExplainResponse>;
     memoryStore(request: EngramAccessMemoryStoreRequest): Promise<EngramAccessWriteResponse>;
@@ -400,6 +431,15 @@ declare class EngramAccessService {
         summaryPath: string;
         reportPath: string;
     }>;
+    procedureMiningRun(request: {
+        namespace?: string;
+        authenticatedPrincipal?: string;
+    }, principal?: string): Promise<{
+        namespace: string;
+        clustersProcessed: number;
+        proceduresWritten: number;
+        skippedReason?: string;
+    }>;
     trustZoneStatus(namespace?: string, principal?: string): Promise<EngramAccessTrustZoneStatusResponse>;
     trustZoneBrowse(request: EngramAccessTrustZoneBrowseRequest, principal?: string): Promise<EngramAccessTrustZoneBrowseResponse>;
     trustZonePromote(request: EngramAccessTrustZonePromoteRequest): Promise<EngramAccessTrustZonePromoteResponse>;
@@ -609,6 +649,27 @@ declare class EngramAccessService {
         saved: boolean;
     }>;
     lcmStatus(): Promise<EngramAccessLcmStatusResponse>;
+    /**
+     * Record citation usage from an observed oai-mem-citation block.
+     * For each citation entry, extract the memory ID from the path and
+     * increment its access tracking via the orchestrator. Returns the
+     * count of submitted IDs and the count of IDs that matched real memories.
+     */
+    recordCitationUsage(request: {
+        sessionId?: string;
+        namespace?: string;
+        authenticatedPrincipal?: string;
+        entries: Array<{
+            path: string;
+            lineStart: number;
+            lineEnd: number;
+            note: string;
+        }>;
+        rolloutIds: string[];
+    }): Promise<{
+        submitted: number;
+        matched: number;
+    }>;
 }
 
-export { ENGRAM_ACCESS_WRITE_SCHEMA_VERSION, type EngramAccessDaySummaryRequest, type EngramAccessEntityListResponse, type EngramAccessEntityResponse, type EngramAccessEntitySummary, type EngramAccessHealthResponse, EngramAccessInputError, type EngramAccessLcmSearchRequest, type EngramAccessLcmSearchResponse, type EngramAccessLcmStatusResponse, type EngramAccessMaintenanceResponse, type EngramAccessMemoryBrowseRequest, type EngramAccessMemoryBrowseResponse, type EngramAccessMemoryRecord, type EngramAccessMemoryResponse, type EngramAccessMemoryStoreRequest, type EngramAccessMemorySummary, type EngramAccessObserveRequest, type EngramAccessObserveResponse, type EngramAccessQualityResponse, type EngramAccessRecallExplainRequest, type EngramAccessRecallExplainResponse, type EngramAccessRecallRequest, type EngramAccessRecallResponse, type EngramAccessReviewDispositionRequest, type EngramAccessReviewDispositionResponse, type EngramAccessReviewQueueResponse, EngramAccessService, type EngramAccessSuggestionSubmitRequest, type EngramAccessTimelineResponse, type EngramAccessTrustZoneBrowseRequest, type EngramAccessTrustZoneBrowseResponse, type EngramAccessTrustZoneDemoSeedRequest, type EngramAccessTrustZoneDemoSeedResponse, type EngramAccessTrustZonePromoteRequest, type EngramAccessTrustZonePromoteResponse, type EngramAccessTrustZoneRecordSummary, type EngramAccessTrustZoneStatusResponse, type EngramAccessWriteEnvelope, type EngramAccessWriteResponse };
+export { ENGRAM_ACCESS_WRITE_SCHEMA_VERSION, type EngramAccessBriefingRequest, type EngramAccessBriefingResponse, type EngramAccessDaySummaryRequest, type EngramAccessEntityListResponse, type EngramAccessEntityResponse, type EngramAccessEntitySummary, type EngramAccessHealthResponse, EngramAccessInputError, type EngramAccessLcmSearchRequest, type EngramAccessLcmSearchResponse, type EngramAccessLcmStatusResponse, type EngramAccessMaintenanceResponse, type EngramAccessMemoryBrowseRequest, type EngramAccessMemoryBrowseResponse, type EngramAccessMemoryRecord, type EngramAccessMemoryResponse, type EngramAccessMemoryStoreRequest, type EngramAccessMemorySummary, type EngramAccessObserveRequest, type EngramAccessObserveResponse, type EngramAccessQualityResponse, type EngramAccessRecallExplainRequest, type EngramAccessRecallExplainResponse, type EngramAccessRecallRequest, type EngramAccessRecallResponse, type EngramAccessReviewDispositionRequest, type EngramAccessReviewDispositionResponse, type EngramAccessReviewQueueResponse, EngramAccessService, type EngramAccessSuggestionSubmitRequest, type EngramAccessTimelineResponse, type EngramAccessTrustZoneBrowseRequest, type EngramAccessTrustZoneBrowseResponse, type EngramAccessTrustZoneDemoSeedRequest, type EngramAccessTrustZoneDemoSeedResponse, type EngramAccessTrustZonePromoteRequest, type EngramAccessTrustZonePromoteResponse, type EngramAccessTrustZoneRecordSummary, type EngramAccessTrustZoneStatusResponse, type EngramAccessWriteEnvelope, type EngramAccessWriteResponse };

package/dist/access-service.js

@@ -2,28 +2,34 @@ import {
   ENGRAM_ACCESS_WRITE_SCHEMA_VERSION,
   EngramAccessInputError,
   EngramAccessService
-} from "./chunk-QY2BHY5O.js";
-import "./chunk-N5AKDXAI.js";
+} from "./chunk-V7XCAHIB.js";
 import "./chunk-EQINRHYR.js";
-import "./chunk-J3BT33K7.js";
+import "./chunk-POBPGDWI.js";
+import "./chunk-QDYXG4CS.js";
+import "./chunk-QNJMBKFK.js";
 import "./chunk-EEQLFRUM.js";
-import "./chunk-QWUUMMIK.js";
-import "./chunk-U4PV25RD.js";
-import "./chunk-ESSMF2FR.js";
+import "./chunk-QDW3E4RD.js";
+import "./chunk-4NRAJUDS.js";
+import "./chunk-DT5TVLJE.js";
+import "./chunk-TBBDFYXW.js";
+import "./chunk-DGXUHMOV.js";
+import "./chunk-LPSF4OQH.js";
+import "./chunk-XKECPATV.js";
+import "./chunk-ECKDIK5F.js";
+import "./chunk-POMSFKTB.js";
+import "./chunk-U2IQTSBY.js";
+import "./chunk-4KAN3GZ3.js";
+import "./chunk-6ZH4TU6I.js";
+import "./chunk-6PFRXT4K.js";
 import "./chunk-TP4FZJIZ.js";
 import "./chunk-SCU65EZI.js";
 import "./chunk-BOUYNNYD.js";
-import "./chunk-DM2T26WE.js";
 import "./chunk-QSVPYQPG.js";
-import "./chunk-YNCQ7E4M.js";
-import "./chunk-HLXVTBF3.js";
+import "./chunk-DM2T26WE.js";
 import "./chunk-M62O4P4T.js";
-import "./chunk-DT5TVLJE.js";
-import "./chunk-KWBU5S5U.js";
-import "./chunk-DGXUHMOV.js";
-import "./chunk-LPSF4OQH.js";
-import "./chunk-XKECPATV.js";
-import "./chunk-QCCCQT3O.js";
+import "./chunk-4DJQYKMN.js";
+import "./chunk-2ODBA7MQ.js";
+import "./chunk-N5AKDXAI.js";
 export {
   ENGRAM_ACCESS_WRITE_SCHEMA_VERSION,
   EngramAccessInputError,

package/dist/active-memory-bridge.d.ts

@@ -0,0 +1,66 @@
+import { PluginConfig, MemoryFile } from './types.js';
+
+interface ActiveMemoryMetadata {
+    type?: "fact" | "preference";
+    topic?: string;
+    updatedAt?: string;
+    sourceUri?: string;
+}
+interface ActiveMemorySearchResult {
+    id: string;
+    score: number;
+    text: string;
+    metadata?: ActiveMemoryMetadata;
+}
+interface ActiveMemorySearchOutput {
+    results: ActiveMemorySearchResult[];
+    truncated: boolean;
+}
+interface ActiveMemoryGetOutput {
+    id?: string;
+    text?: string;
+    metadata?: ActiveMemoryMetadata;
+    error?: "not_found";
+}
+interface ActiveMemoryRecallParams {
+    query: string;
+    limit?: number;
+    sessionKey: string;
+    filters?: Record<string, unknown>;
+    snippetMaxChars?: number;
+}
+type ActiveMemorySearchCandidate = {
+    id?: string;
+    score?: number;
+    snippet?: string;
+    text?: string;
+    path?: string;
+    metadata?: Record<string, unknown>;
+};
+declare function recallForActiveMemory(orchestrator: {
+    config?: PluginConfig;
+    resolvePrincipal?: (sessionKey?: string) => string;
+    resolveSelfNamespace?: (sessionKey?: string) => string;
+    searchAcrossNamespaces: (params: {
+        query: string;
+        maxResults?: number;
+        namespaces?: string[];
+        mode?: string;
+    }) => Promise<ActiveMemorySearchCandidate[]>;
+}, params: ActiveMemoryRecallParams): Promise<ActiveMemorySearchOutput>;
+declare function getMemoryForActiveMemory(orchestrator: {
+    config?: PluginConfig;
+    resolvePrincipal?: (sessionKey?: string) => string;
+    resolveSelfNamespace?: (sessionKey?: string) => string;
+    getStorageForNamespace?: (namespace: string) => Promise<{
+        getMemoryById?: (id: string) => Promise<MemoryFile | null>;
+    }>;
+    storage?: {
+        getMemoryById?: (id: string) => Promise<MemoryFile | null>;
+    };
+}, id: string, options?: {
+    namespace?: string;
+    sessionKey?: string;
+}): Promise<ActiveMemoryGetOutput>;
+
+export { type ActiveMemoryGetOutput, type ActiveMemoryMetadata, type ActiveMemoryRecallParams, type ActiveMemorySearchOutput, type ActiveMemorySearchResult, getMemoryForActiveMemory, recallForActiveMemory };

package/dist/active-memory-bridge.js

@@ -0,0 +1,11 @@
+import {
+  getMemoryForActiveMemory,
+  recallForActiveMemory
+} from "./chunk-G4SK7DSQ.js";
+import "./chunk-6MKAMLQL.js";
+import "./chunk-N5AKDXAI.js";
+export {
+  getMemoryForActiveMemory,
+  recallForActiveMemory
+};
+//# sourceMappingURL=active-memory-bridge.js.map

package/dist/active-recall.d.ts

@@ -0,0 +1,96 @@
+import { ActiveRecallChatType, ActiveRecallQueryMode, ActiveRecallPromptStyle, ActiveRecallThinking, ActiveRecallModelFallbackPolicy } from './types.js';
+
+interface ActiveRecallTurn {
+    role: "user" | "assistant";
+    content: string;
+}
+interface ActiveRecallInput {
+    sessionKey: string;
+    agentId: string;
+    chatType: ActiveRecallChatType;
+    recentTurns: ActiveRecallTurn[];
+    currentMessage: string;
+}
+interface ActiveRecallConfig {
+    enabled: boolean;
+    agents: string[] | null;
+    allowedChatTypes: ActiveRecallChatType[];
+    queryMode: ActiveRecallQueryMode;
+    promptStyle: ActiveRecallPromptStyle;
+    promptOverride: string | null;
+    promptAppend: string | null;
+    maxSummaryChars: number;
+    recentUserTurns: number;
+    recentAssistantTurns: number;
+    recentUserChars: number;
+    recentAssistantChars: number;
+    thinking: ActiveRecallThinking;
+    timeoutMs: number;
+    cacheTtlMs: number;
+    persistTranscripts: boolean;
+    transcriptDir: string;
+    entityGraphDepth: number;
+    includeCausalTrajectories: boolean;
+    includeDaySummary: boolean;
+    attachRecallExplain: boolean;
+    modelOverride: string | null;
+    modelFallbackPolicy: ActiveRecallModelFallbackPolicy;
+}
+interface ActiveRecallResult {
+    summary: string | null;
+    citations: Array<{
+        memoryId: string;
+        relevance: number;
+    }>;
+    latencyMs: number;
+    cacheHit: boolean;
+    modelUsed: string;
+    transcriptPath: string | null;
+}
+interface ActiveRecallDependencies {
+    recall(query: string, sessionKey: string): Promise<string | null>;
+    getLastRecallSnapshot?(sessionKey: string): {
+        memoryIds?: string[];
+    } | null;
+    walkEntityGraph?(params: {
+        sessionKey: string;
+        query: string;
+        depth: number;
+    }): Promise<string[]>;
+    loadCausalTrajectories?(params: {
+        sessionKey: string;
+        query: string;
+    }): Promise<string[]>;
+    loadDaySummary?(sessionKey: string): Promise<string | null>;
+    explainLastRecall?(sessionKey: string): Promise<string | null>;
+    generateSummary?(params: {
+        prompt: string;
+        sessionKey: string;
+        agentId: string;
+        model: string;
+        timeoutMs: number;
+        thinking: ActiveRecallThinking;
+        fallbackPolicy: ActiveRecallModelFallbackPolicy;
+    }): Promise<{
+        text: string | null;
+        modelUsed?: string;
+        cacheHit?: boolean;
+    }>;
+    now?: () => number;
+}
+declare function buildActiveRecallQueryBundle(input: ActiveRecallInput, config: ActiveRecallConfig): string;
+declare function normalizeActiveRecallSummary(value: string | null, maxChars: number): string | null;
+declare function buildActiveRecallPrompt(params: {
+    config: ActiveRecallConfig;
+    queryBundle: string;
+    recallContext: string | null;
+    graphContext: string[];
+    causalContext: string[];
+    daySummary: string | null;
+    recallExplain: string | null;
+}): string;
+declare function createActiveRecallEngine(deps: ActiveRecallDependencies, config: ActiveRecallConfig): {
+    run(input: ActiveRecallInput): Promise<ActiveRecallResult>;
+};
+
+export { type ActiveRecallConfig, type ActiveRecallDependencies, type ActiveRecallInput, type ActiveRecallResult, type ActiveRecallTurn, buildActiveRecallPrompt, buildActiveRecallQueryBundle, createActiveRecallEngine, normalizeActiveRecallSummary };

package/dist/active-recall.js

@@ -0,0 +1,308 @@
+import {
+  collapseWhitespace,
+  truncateCodePointSafe
+} from "./chunk-6MKAMLQL.js";
+
+// src/active-recall.ts
+import { appendFile, mkdir } from "fs/promises";
+import path from "path";
+var ACTIVE_RECALL_CACHE_MAX_ENTRIES = 256;
+var NONE_SET = /* @__PURE__ */ new Set([
+  "",
+  "none",
+  "no_reply",
+  "nothing useful",
+  "no relevant memory",
+  "timeout",
+  "[]",
+  "{}",
+  "null",
+  "n/a"
+]);
+var STYLE_INSTRUCTIONS = {
+  balanced: "Summarize the most relevant memory context in a compact, neutral way.",
+  strict: "Only include memory that is directly supported by the retrieved context.",
+  contextual: "Prefer concise context that helps the next reply stay grounded in recent work.",
+  "recall-heavy": "Bias toward richer recall coverage when multiple retrieved items reinforce each other.",
+  "precision-heavy": "Bias toward precision. Omit anything uncertain or weakly supported.",
+  "preference-only": "Only surface user preference or operating-style memory when present."
+};
+function cloneRecallResult(value) {
+  return {
+    ...value,
+    citations: [...value.citations]
+  };
+}
+function buildCacheKey(input, config, queryBundle) {
+  return JSON.stringify({
+    sessionKey: input.sessionKey,
+    agentId: input.agentId,
+    queryMode: config.queryMode,
+    promptStyle: config.promptStyle,
+    promptOverride: config.promptOverride,
+    promptAppend: config.promptAppend,
+    maxSummaryChars: config.maxSummaryChars,
+    entityGraphDepth: config.entityGraphDepth,
+    includeCausalTrajectories: config.includeCausalTrajectories,
+    includeDaySummary: config.includeDaySummary,
+    attachRecallExplain: config.attachRecallExplain,
+    modelOverride: config.modelOverride,
+    modelFallbackPolicy: config.modelFallbackPolicy,
+    thinking: config.thinking,
+    queryBundle
+  });
+}
+function pruneExpiredCache(cache, currentTime) {
+  for (const [key, entry] of cache.entries()) {
+    if (entry.expiresAt <= currentTime) {
+      cache.delete(key);
+    }
+  }
+}
+function enforceCacheLimit(cache) {
+  while (cache.size > ACTIVE_RECALL_CACHE_MAX_ENTRIES) {
+    const oldestKey = cache.keys().next().value;
+    if (typeof oldestKey !== "string") {
+      break;
+    }
+    cache.delete(oldestKey);
+  }
+}
+function cropTurns(turns, role, maxTurns, maxChars) {
+  if (maxTurns <= 0) {
+    return [];
+  }
+  const selected = [];
+  for (let index = turns.length - 1; index >= 0 && selected.length < maxTurns; index -= 1) {
+    const turn = turns[index];
+    if (turn?.role === role) {
+      selected.push({
+        index,
+        role: turn.role,
+        content: collapseWhitespace(truncateCodePointSafe(turn.content, maxChars))
+      });
+    }
+  }
+  return selected.reverse();
+}
+function mergeChronologicalTurns(userTurns, assistantTurns) {
+  return [...userTurns, ...assistantTurns].sort((left, right) => left.index - right.index).filter((value) => value.content.length > 0);
+}
+function buildActiveRecallQueryBundle(input, config) {
+  if (config.queryMode === "message") {
+    return collapseWhitespace(input.currentMessage);
+  }
+  const userTurns = cropTurns(
+    input.recentTurns,
+    "user",
+    config.recentUserTurns,
+    config.recentUserChars
+  );
+  const assistantTurns = cropTurns(
+    input.recentTurns,
+    "assistant",
+    config.recentAssistantTurns,
+    config.recentAssistantChars
+  );
+  const mergedTurns = mergeChronologicalTurns(userTurns, assistantTurns);
+  const parts = [
+    ...mergedTurns.map((turn) => `${turn.role}: ${turn.content}`)
+  ];
+  if (config.queryMode === "full") {
+    return [...parts, `current: ${collapseWhitespace(input.currentMessage)}`].filter((value) => value.trim().length > 0).join("\n");
+  }
+  return [`current: ${collapseWhitespace(input.currentMessage)}`, ...parts].filter((value) => value.trim().length > 0).join("\n");
+}
+function normalizeActiveRecallSummary(value, maxChars) {
+  if (value == null) return null;
+  const compact = collapseWhitespace(value);
+  if (NONE_SET.has(compact.toLowerCase())) return null;
+  return truncateCodePointSafe(compact, maxChars);
+}
+function sanitizeTranscriptPathSegment(value) {
+  const normalized = collapseWhitespace(value);
+  return encodeURIComponent(normalized.length > 0 ? normalized : "unknown").replaceAll(
+    ".",
+    "%2E"
+  );
+}
+function buildActiveRecallPrompt(params) {
+  const sections = [
+    params.config.promptOverride?.trim() || STYLE_INSTRUCTIONS[params.config.promptStyle],
+    `Query bundle:
+${params.queryBundle}`,
+    params.recallContext ? `Retrieved memory:
+${params.recallContext}` : null,
+    params.graphContext.length > 0 ? `Entity graph:
+${params.graphContext.join("\n")}` : null,
+    params.causalContext.length > 0 ? `Causal trajectories:
+${params.causalContext.join("\n")}` : null,
+    params.daySummary ? `Day summary:
+${params.daySummary}` : null,
+    params.recallExplain ? `Recall explain:
+${params.recallExplain}` : null,
+    params.config.promptAppend?.trim() || null,
+    "Return either NONE or a compact summary grounded only in the supplied context."
+  ];
+  return sections.filter((value) => !!value && value.trim().length > 0).join("\n\n");
+}
+async function appendActiveRecallTranscript(transcriptRoot, input, config, result, queryBundle) {
+  const date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  const filePath = path.join(
+    transcriptRoot,
+    "agents",
+    sanitizeTranscriptPathSegment(input.agentId),
+    date,
+    `${sanitizeTranscriptPathSegment(input.sessionKey)}.jsonl`
+  );
+  await mkdir(path.dirname(filePath), { recursive: true });
+  await appendFile(
+    filePath,
+    `${JSON.stringify({
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      sessionKey: input.sessionKey,
+      agentId: input.agentId,
+      queryMode: config.queryMode,
+      promptStyle: config.promptStyle,
+      queryBundle,
+      summary: result.summary,
+      citations: result.citations,
+      latencyMs: result.latencyMs,
+      cacheHit: result.cacheHit,
+      modelUsed: result.modelUsed
+    })}
+`,
+    "utf8"
+  );
+  return filePath;
+}
+function createActiveRecallEngine(deps, config) {
+  const cache = /* @__PURE__ */ new Map();
+  const now = deps.now ?? (() => Date.now());
+  return {
+    async run(input) {
+      if (!config.enabled) {
+        return {
+          summary: null,
+          citations: [],
+          latencyMs: 0,
+          cacheHit: false,
+          modelUsed: config.modelOverride ?? "disabled",
+          transcriptPath: null
+        };
+      }
+      if (config.agents && !config.agents.includes(input.agentId)) {
+        return {
+          summary: null,
+          citations: [],
+          latencyMs: 0,
+          cacheHit: false,
+          modelUsed: config.modelOverride ?? "filtered",
+          transcriptPath: null
+        };
+      }
+      if (!config.allowedChatTypes.includes(input.chatType)) {
+        return {
+          summary: null,
+          citations: [],
+          latencyMs: 0,
+          cacheHit: false,
+          modelUsed: config.modelOverride ?? "filtered",
+          transcriptPath: null
+        };
+      }
+      const queryBundle = buildActiveRecallQueryBundle(input, config);
+      const cacheKey = buildCacheKey(input, config, queryBundle);
+      const currentTime = now();
+      const cacheEnabled = config.cacheTtlMs > 0;
+      if (cacheEnabled) {
+        pruneExpiredCache(cache, currentTime);
+      }
+      const cached = cache.get(cacheKey);
+      if (cacheEnabled && cached) {
+        return {
+          ...cloneRecallResult(cached.value),
+          latencyMs: Math.max(0, now() - currentTime),
+          cacheHit: true
+        };
+      }
+      const start = currentTime;
+      const recallContext = await deps.recall(queryBundle, input.sessionKey);
+      const graphContext = config.entityGraphDepth > 0 && deps.walkEntityGraph ? await deps.walkEntityGraph({
+        sessionKey: input.sessionKey,
+        query: queryBundle,
+        depth: config.entityGraphDepth
+      }) : [];
+      const causalContext = config.includeCausalTrajectories && deps.loadCausalTrajectories ? await deps.loadCausalTrajectories({
+        sessionKey: input.sessionKey,
+        query: queryBundle
+      }) : [];
+      const daySummary = config.includeDaySummary && deps.loadDaySummary ? await deps.loadDaySummary(input.sessionKey) : null;
+      const recallExplain = config.attachRecallExplain && deps.explainLastRecall ? await deps.explainLastRecall(input.sessionKey) : null;
+      const prompt = buildActiveRecallPrompt({
+        config,
+        queryBundle,
+        recallContext,
+        graphContext,
+        causalContext,
+        daySummary,
+        recallExplain
+      });
+      const generated = deps.generateSummary ? await deps.generateSummary({
+        prompt,
+        sessionKey: input.sessionKey,
+        agentId: input.agentId,
+        model: config.modelOverride ?? "gpt-5.2",
+        timeoutMs: config.timeoutMs,
+        thinking: config.thinking,
+        fallbackPolicy: config.modelFallbackPolicy
+      }) : {
+        text: recallContext,
+        modelUsed: config.modelOverride ?? "gpt-5.2",
+        cacheHit: false
+      };
+      const summary = normalizeActiveRecallSummary(
+        generated.text,
+        config.maxSummaryChars
+      );
+      const snapshot = deps.getLastRecallSnapshot?.(input.sessionKey);
+      const citations = (snapshot?.memoryIds ?? []).map((memoryId, index) => ({
+        memoryId,
+        relevance: Number((1 / (index + 1)).toFixed(3))
+      }));
+      const result = {
+        summary,
+        citations,
+        latencyMs: Math.max(0, now() - start),
+        cacheHit: generated.cacheHit === true,
+        modelUsed: generated.modelUsed ?? config.modelOverride ?? "gpt-5.2",
+        transcriptPath: null
+      };
+      if (config.persistTranscripts) {
+        result.transcriptPath = await appendActiveRecallTranscript(
+          config.transcriptDir,
+          input,
+          config,
+          result,
+          queryBundle
+        );
+      }
+      if (cacheEnabled) {
+        const completedAt = now();
+        cache.set(cacheKey, {
+          expiresAt: completedAt + config.cacheTtlMs,
+          value: cloneRecallResult(result)
+        });
+        enforceCacheLimit(cache);
+      }
+      return result;
+    }
+  };
+}
+export {
+  buildActiveRecallPrompt,
+  buildActiveRecallQueryBundle,
+  createActiveRecallEngine,
+  normalizeActiveRecallSummary
+};
+//# sourceMappingURL=active-recall.js.map