@graphorin/memory 0.6.0 → 0.7.0

package/src/tools/index.ts

@@ -0,0 +1,109 @@
+/**
+ * Eleven memory tools registered with `@graphorin/tools` by the
+ * `createMemory()` facade - plus an opt-in twelfth, `deep_recall` (P2-4),
+ * appended only when iterative retrieval is configured. Each factory
+ * takes a {@link MemoryToolDeps} bundle so consumers can scope the tool
+ * surface (per-tier ACL, scope resolver, etc.) without rebuilding the
+ * underlying memory facade.
+ *
+ * @packageDocumentation
+ */
+
+import type { Tool } from '@graphorin/core';
+import {
+  createBlockAppendTool,
+  createBlockReplaceTool,
+  createBlockRethinkTool,
+} from './block-tools.js';
+import {
+  createFactForgetTool,
+  createFactHistoryTool,
+  createFactRememberTool,
+  createFactSearchTool,
+  createFactSupersedeTool,
+  createFactValidateTool,
+} from './fact-tools.js';
+import {
+  createConversationSearchTool,
+  createDeepRecallTool,
+  createRecallEpisodesTool,
+} from './recall-tools.js';
+import { createRunbookSearchTool } from './runbook-tools.js';
+import type { MemoryToolDeps } from './types.js';
+
+export {
+  createBlockAppendTool,
+  createBlockReplaceTool,
+  createBlockRethinkTool,
+} from './block-tools.js';
+export {
+  createFactForgetTool,
+  createFactHistoryTool,
+  createFactRememberTool,
+  createFactSearchTool,
+  createFactSupersedeTool,
+  createFactValidateTool,
+} from './fact-tools.js';
+export {
+  createConversationSearchTool,
+  createDeepRecallTool,
+  createRecallEpisodesTool,
+} from './recall-tools.js';
+export { createRunbookSearchTool } from './runbook-tools.js';
+export type { MemoryToolDeps, ScopeResolver } from './types.js';
+
+/**
+ * Options for {@link buildMemoryTools}.
+ *
+ * @stable
+ */
+export interface BuildMemoryToolsOptions {
+  /**
+   * Append the gated `deep_recall` tool (P2-4) as a twelfth tool. The
+   * facade sets this only when `iterativeRetrieval` is configured, so the
+   * default tool surface stays at the canonical eleven. Default `false`.
+   */
+  readonly includeDeepRecall?: boolean;
+  /**
+   * Append the gated `runbook_search` tool (D3). The facade sets this
+   * only when `createMemory({ runbookSearch: true })` opts in, so the
+   * default tool surface is unchanged. Default `false`.
+   */
+  readonly includeRunbookSearch?: boolean;
+}
+
+/**
+ * Build the canonical eleven-memory-tool array. Order is stable -
+ * consumers can rely on the indices for snapshot tests. `fact_history`
+ * (P0-2) and `fact_validate` (P1-4) are appended last so the original
+ * nine indices are unchanged. With `{ includeDeepRecall: true }` the
+ * gated `deep_recall` tool (P2-4) is appended as a twelfth, after the
+ * stable eleven.
+ *
+ * @stable
+ */
+export function buildMemoryTools(
+  deps: MemoryToolDeps,
+  options: BuildMemoryToolsOptions = {},
+): ReadonlyArray<Tool> {
+  const tools: Tool[] = [
+    createBlockAppendTool(deps) as Tool,
+    createBlockReplaceTool(deps) as Tool,
+    createBlockRethinkTool(deps) as Tool,
+    createFactRememberTool(deps) as Tool,
+    createFactSearchTool(deps) as Tool,
+    createFactSupersedeTool(deps) as Tool,
+    createFactForgetTool(deps) as Tool,
+    createRecallEpisodesTool(deps) as Tool,
+    createConversationSearchTool(deps) as Tool,
+    createFactHistoryTool(deps) as Tool,
+    createFactValidateTool(deps) as Tool,
+  ];
+  if (options.includeDeepRecall === true) {
+    tools.push(createDeepRecallTool(deps) as Tool);
+  }
+  if (options.includeRunbookSearch === true) {
+    tools.push(createRunbookSearchTool(deps) as Tool);
+  }
+  return Object.freeze(tools);
+}

package/src/tools/recall-tools.ts

@@ -0,0 +1,303 @@
+import type { Tool } from '@graphorin/core';
+import { toolReturn } from '@graphorin/core';
+import { tool } from '@graphorin/tools';
+import { z } from 'zod';
+import { recallTaint } from './taint.js';
+import type { MemoryToolDeps } from './types.js';
+
+const recallEpisodesInputSchema = z.object({
+  query: z.string().min(1).max(1024),
+  topK: z.number().int().positive().max(20).optional(),
+  dateRange: z
+    .object({
+      from: z.string().datetime().optional(),
+      to: z.string().datetime().optional(),
+    })
+    .optional(),
+});
+const recallEpisodesOutputSchema = z.object({
+  episodes: z.array(
+    z.object({
+      episodeId: z.string(),
+      summary: z.string(),
+      score: z.number(),
+      startedAt: z.string(),
+      endedAt: z.string(),
+      /** Trust-provenance tag (MST-10) - synthesized episodes say so. */
+      provenance: z.string().optional(),
+    }),
+  ),
+});
+
+/** W-013: explicit interfaces (see fact-tools.ts) - no zod generics in d.ts. */
+export interface RecallEpisodesInput {
+  query: string;
+  topK?: number | undefined;
+  dateRange?: { from?: string | undefined; to?: string | undefined } | undefined;
+}
+export interface RecallEpisodeHit {
+  episodeId: string;
+  summary: string;
+  score: number;
+  startedAt: string;
+  endedAt: string;
+  provenance?: string | undefined;
+}
+export interface RecallEpisodesOutput {
+  episodes: RecallEpisodeHit[];
+}
+
+const conversationSearchInputSchema = z.object({
+  query: z.string().min(1).max(1024),
+  topK: z.number().int().positive().max(20).optional(),
+});
+const conversationSearchOutputSchema = z.object({
+  matches: z.array(
+    z.object({
+      messageId: z.string(),
+      score: z.number(),
+    }),
+  ),
+});
+
+export interface ConversationSearchInput {
+  query: string;
+  topK?: number | undefined;
+}
+export interface ConversationSearchOutput {
+  matches: Array<{ messageId: string; score: number }>;
+}
+
+const deepRecallSensitivityEnum = z.enum(['public', 'internal', 'secret']);
+const deepRecallInputSchema = z.object({
+  query: z.string().min(1).max(1024),
+  topK: z.number().int().positive().max(50).optional(),
+  maxIterations: z.number().int().min(1).max(5).optional(),
+  asOf: z.string().datetime().optional(),
+});
+const deepRecallOutputSchema = z.object({
+  hits: z.array(
+    z.object({
+      factId: z.string(),
+      text: z.string(),
+      score: z.number(),
+      sensitivity: deepRecallSensitivityEnum,
+      /** Trust-provenance tag (MST-10) - synthesized facts say so. */
+      provenance: z.string().optional(),
+      /** Closed validity end (only surfaces on `asOf` reads). */
+      validTo: z.string().optional(),
+      /** Id of the fact that superseded this one, when any. */
+      supersededBy: z.string().optional(),
+    }),
+  ),
+  sufficient: z.boolean(),
+  abstained: z.boolean(),
+  /**
+   * Whether the grader actually judged sufficiency
+   * (memory-retrieval-02). When `false`, `sufficient: true` is a
+   * default, not a verdict.
+   */
+  graded: z.boolean(),
+  iterations: z.number().int(),
+});
+
+export interface DeepRecallInput {
+  query: string;
+  topK?: number | undefined;
+  maxIterations?: number | undefined;
+  asOf?: string | undefined;
+}
+export interface DeepRecallHit {
+  factId: string;
+  text: string;
+  score: number;
+  sensitivity: 'public' | 'internal' | 'secret';
+  provenance?: string | undefined;
+  validTo?: string | undefined;
+  supersededBy?: string | undefined;
+}
+export interface DeepRecallOutput {
+  hits: DeepRecallHit[];
+  sufficient: boolean;
+  abstained: boolean;
+  graded: boolean;
+  iterations: number;
+}
+
+// W-013 parity gate (compile-time only, erased from the build and the
+// d.ts): each explicit interface must stay MUTUALLY assignable with its
+// schema's inference - a drifted transcription fails `tsc` right here.
+type W013Equals<A, B> = A extends B ? (B extends A ? true : false) : false;
+type W013Assert<T extends true> = T;
+type _W013Check1 = W013Assert<
+  W013Equals<RecallEpisodesInput, z.infer<typeof recallEpisodesInputSchema>>
+>;
+type _W013Check2 = W013Assert<
+  W013Equals<RecallEpisodesOutput, z.infer<typeof recallEpisodesOutputSchema>>
+>;
+type _W013Check3 = W013Assert<
+  W013Equals<ConversationSearchInput, z.infer<typeof conversationSearchInputSchema>>
+>;
+type _W013Check4 = W013Assert<
+  W013Equals<ConversationSearchOutput, z.infer<typeof conversationSearchOutputSchema>>
+>;
+type _W013Check5 = W013Assert<W013Equals<DeepRecallInput, z.infer<typeof deepRecallInputSchema>>>;
+type _W013Check6 = W013Assert<W013Equals<DeepRecallOutput, z.infer<typeof deepRecallOutputSchema>>>;
+
+/**
+ * `recall_episodes` - triple-signal episode retrieval (recency ×
+ * relevance × importance).
+ *
+ * @stable
+ */
+export function createRecallEpisodesTool(
+  deps: MemoryToolDeps,
+): Tool<RecallEpisodesInput, RecallEpisodesOutput> {
+  return tool<RecallEpisodesInput, RecallEpisodesOutput>({
+    name: 'recall_episodes',
+    description:
+      "Recall summarized episodes (multi-message stretches of past activity) matching a natural-language query. Combines vector relevance, time-decay recency, and the per-episode importance score. Use for long-horizon recall ('the last time we discussed X').",
+    inputSchema: recallEpisodesInputSchema,
+    outputSchema: recallEpisodesOutputSchema,
+    sideEffectClass: 'read-only',
+    sandboxPolicy: 'none',
+    sensitivity: 'internal',
+    memoryGuardTier: 'pure',
+    tags: ['memory', 'episodic'],
+    async execute(input, ctx) {
+      const scope = await deps.resolveScope(ctx);
+      const dateRange =
+        input.dateRange !== undefined
+          ? {
+              ...(input.dateRange.from !== undefined ? { from: input.dateRange.from } : {}),
+              ...(input.dateRange.to !== undefined ? { to: input.dateRange.to } : {}),
+            }
+          : undefined;
+      const hits = await deps.episodic.search(scope, input.query, {
+        ...(input.topK !== undefined ? { topK: input.topK } : {}),
+        ...(dateRange !== undefined ? { dateRange } : {}),
+        signal: ctx.signal,
+      });
+      const output = {
+        episodes: hits.map((hit) => ({
+          episodeId: hit.record.id,
+          summary: hit.record.summary,
+          score: hit.score,
+          startedAt: hit.record.startedAt,
+          endedAt: hit.record.endedAt,
+          // MST-10: surface origin so a consumer can tell a synthesized
+          // (consolidator-extracted) episode from a first-party record -
+          // recalled text re-enters the model as trusted tool output.
+          ...(hit.record.provenance !== undefined ? { provenance: hit.record.provenance } : {}),
+        })),
+      };
+      // C6: recalled foreign-provenance / quarantined episodes re-arm the
+      // taint ledger (the cross-session poisoning leg).
+      const taint = recallTaint(hits.map((h) => h.record));
+      return taint === undefined ? output : toolReturn({ output, taint });
+    },
+  });
+}
+
+/**
+ * `conversation_search` - FTS5 search over the active session
+ * messages.
+ *
+ * @stable
+ */
+export function createConversationSearchTool(
+  deps: MemoryToolDeps,
+): Tool<ConversationSearchInput, ConversationSearchOutput> {
+  return tool<ConversationSearchInput, ConversationSearchOutput>({
+    name: 'conversation_search',
+    description:
+      'Search the active session message log by natural-language query. Returns up to `topK` matched messages with their stable id and BM25 score.',
+    inputSchema: conversationSearchInputSchema,
+    outputSchema: conversationSearchOutputSchema,
+    sideEffectClass: 'read-only',
+    sandboxPolicy: 'none',
+    sensitivity: 'internal',
+    memoryGuardTier: 'pure',
+    tags: ['memory', 'session'],
+    async execute(input, ctx) {
+      const scope = await deps.resolveScope(ctx);
+      const hits = await deps.session.search(scope, input.query, {
+        ...(input.topK !== undefined ? { topK: input.topK } : {}),
+        signal: ctx.signal,
+      });
+      return {
+        matches: hits.map((hit) => ({
+          messageId: hit.record.id,
+          score: hit.score,
+        })),
+      };
+    },
+  });
+}
+
+/**
+ * `deep_recall` - gated, multi-pass ("deep") recall over the user's
+ * factual memory for HARD questions (P2-4). A local difficulty gate keeps
+ * simple lookups single-shot; only queries judged hard trigger a
+ * grade-and-reformulate loop (bounded by `maxIterations`, hard-capped at
+ * 5), widening to one-hop graph expansion on reformulation passes. The
+ * output reports `abstained: true` when memory was insufficient even
+ * after reformulating - the agent should then say it lacks the
+ * information rather than guess. Registered only when the facade is
+ * created with `iterativeRetrieval`; otherwise it degrades to a single
+ * pass, so prefer the cheaper `fact_search` for ordinary lookups.
+ *
+ * @stable
+ */
+export function createDeepRecallTool(
+  deps: MemoryToolDeps,
+): Tool<DeepRecallInput, DeepRecallOutput> {
+  return tool<DeepRecallInput, DeepRecallOutput>({
+    name: 'deep_recall',
+    description:
+      "Multi-pass ('deep') recall over the user's long-term factual memory for HARD multi-hop or temporal questions one search can't answer (e.g. 'who recommended the book the person I met in Tbilisi mentioned?'). A difficulty gate keeps simple lookups single-shot; hard questions trigger a bounded grade-and-reformulate loop. If `abstained` is true the memory was insufficient even after reformulating - tell the user you don't have enough stored to answer and DO NOT guess. Prefer the cheaper fact_search for ordinary lookups.",
+    inputSchema: deepRecallInputSchema,
+    outputSchema: deepRecallOutputSchema,
+    sideEffectClass: 'read-only',
+    sandboxPolicy: 'none',
+    sensitivity: 'internal',
+    memoryGuardTier: 'pure',
+    tags: ['memory', 'semantic'],
+    async execute(input, ctx) {
+      const scope = await deps.resolveScope(ctx);
+      const result = await deps.semantic.searchIterative(scope, input.query, {
+        ...(input.topK !== undefined ? { topK: input.topK } : {}),
+        ...(input.maxIterations !== undefined ? { maxIterations: input.maxIterations } : {}),
+        ...(input.asOf !== undefined ? { asOf: input.asOf } : {}),
+        // memory-retrieval-02: the model choosing deep_recall over
+        // fact_search IS the hardness signal - the local heuristic gate
+        // rejected the tool's own documented multi-hop examples
+        // (W_MULTI_HOP 0.4 < threshold 0.5) and is English-only. The
+        // cap + grader stop conditions still bound cost.
+        forceHard: true,
+        signal: ctx.signal,
+      });
+      const output = {
+        hits: result.hits.map((hit) => ({
+          factId: hit.record.id,
+          text: hit.record.text,
+          score: hit.score,
+          sensitivity: hit.record.sensitivity,
+          // MST-10: origin annotation, mirroring fact_search.
+          ...(hit.record.provenance !== undefined ? { provenance: hit.record.provenance } : {}),
+          ...(hit.record.validTo !== undefined ? { validTo: hit.record.validTo } : {}),
+          ...(hit.record.supersededBy !== undefined
+            ? { supersededBy: hit.record.supersededBy }
+            : {}),
+        })),
+        sufficient: result.sufficient,
+        abstained: result.abstained,
+        graded: result.graded,
+        iterations: result.iterations,
+      };
+      // C6: mirror fact_search - recalled poisoned content re-arms the ledger.
+      const taint = recallTaint(result.hits.map((h) => h.record));
+      return taint === undefined ? output : toolReturn({ output, taint });
+    },
+  });
+}

package/src/tools/runbook-tools.ts

@@ -0,0 +1,107 @@
+/**
+ * Runbook tool (D3) - gated content recall over procedural memory.
+ * `runbook_search` finds validated procedures whose text / steps match
+ * a task description and returns them **whole** (title line, numbered
+ * steps, variables, success criteria), so the model can follow a known
+ * workflow file-style instead of re-deriving it. Registered only when
+ * the facade opts in (`createMemory({ runbookSearch: true })`) - the
+ * default tool surface is unchanged.
+ *
+ * @packageDocumentation
+ */
+
+import type { Tool } from '@graphorin/core';
+import { tool } from '@graphorin/tools';
+import { z } from 'zod';
+import type { MemoryToolDeps } from './types.js';
+
+const runbookSearchInputSchema = z.object({
+  query: z.string().min(1).max(512),
+  topK: z.number().int().min(1).max(20).optional(),
+});
+const runbookSearchOutputSchema = z.object({
+  procedures: z.array(
+    z.object({
+      id: z.string(),
+      text: z.string(),
+      steps: z.array(z.string()).optional(),
+      variables: z.array(z.string()).optional(),
+      successCriteria: z.array(z.string()).optional(),
+      priority: z.number(),
+      score: z.number(),
+    }),
+  ),
+});
+
+/** W-013: explicit interfaces (see fact-tools.ts) - no zod generics in d.ts. */
+export interface RunbookSearchInput {
+  query: string;
+  topK?: number | undefined;
+}
+export interface RunbookProcedureHit {
+  id: string;
+  text: string;
+  steps?: string[] | undefined;
+  variables?: string[] | undefined;
+  successCriteria?: string[] | undefined;
+  priority: number;
+  score: number;
+}
+export interface RunbookSearchOutput {
+  procedures: RunbookProcedureHit[];
+}
+
+// W-013 parity gate (compile-time only, erased from the build and the
+// d.ts): each explicit interface must stay MUTUALLY assignable with its
+// schema's inference - a drifted transcription fails `tsc` right here.
+type W013Equals<A, B> = A extends B ? (B extends A ? true : false) : false;
+type W013Assert<T extends true> = T;
+type _W013Check1 = W013Assert<
+  W013Equals<RunbookSearchInput, z.infer<typeof runbookSearchInputSchema>>
+>;
+type _W013Check2 = W013Assert<
+  W013Equals<RunbookSearchOutput, z.infer<typeof runbookSearchOutputSchema>>
+>;
+
+/**
+ * `runbook_search` - find validated procedures matching a task
+ * description. Quarantined (unvalidated induced) procedures never
+ * surface here: they must not drive actions until validated.
+ *
+ * @stable
+ */
+export function createRunbookSearchTool(
+  deps: MemoryToolDeps,
+): Tool<RunbookSearchInput, RunbookSearchOutput> {
+  return tool<RunbookSearchInput, RunbookSearchOutput>({
+    name: 'runbook_search',
+    description:
+      'Find a stored, validated procedure ("runbook") matching the task at hand - e.g. "deploy the docs site" or "rotate the API key". Returns whole procedures with their numbered steps, variables, and success criteria so you can follow a known-good workflow instead of improvising. Use BEFORE attempting a multi-step operational task the user may have done with you previously.',
+    inputSchema: runbookSearchInputSchema,
+    outputSchema: runbookSearchOutputSchema,
+    sideEffectClass: 'read-only',
+    sandboxPolicy: 'none',
+    sensitivity: 'internal',
+    memoryGuardTier: 'pure',
+    tags: ['memory', 'procedural'],
+    async execute(input, ctx) {
+      const scope = await deps.resolveScope(ctx);
+      const hits = await deps.procedural.search(scope, input.query, {
+        ...(input.topK !== undefined ? { topK: input.topK } : {}),
+      });
+      return {
+        procedures: hits.map((hit) => ({
+          id: hit.record.id,
+          text: hit.record.text,
+          ...(hit.record.steps !== undefined ? { steps: [...hit.record.steps] } : {}),
+          ...(hit.record.variables !== undefined ? { variables: [...hit.record.variables] } : {}),
+          ...(hit.record.successCriteria !== undefined
+            ? { successCriteria: [...hit.record.successCriteria] }
+            : {}),
+          priority: hit.record.priority,
+          score: hit.score,
+        })),
+      };
+    },
+  });
+}

package/src/tools/taint.ts

@@ -0,0 +1,39 @@
+/**
+ * C6: taint override for memory-recall tool results. The recall tools are
+ * first-party (`sideEffectClass: 'read-only'`), so the data-flow ledger
+ * would derive their outputs as trusted - but the CONTENT they return can
+ * be quarantined or foreign-provenance memory written in an earlier
+ * session (the cross-session poisoning leg). This helper computes the
+ * `ToolReturn.taint` override that re-arms the ledger at recall: recalled
+ * poisoned content is recorded as untrusted spans, so the verbatim probe
+ * and the trifecta/derived gates see it exactly like fresh untrusted
+ * input.
+ *
+ * @packageDocumentation
+ */
+
+import { isForeignProvenance } from '../search/trust.js';
+
+/** Minimal record surface the helper inspects. */
+export interface RecalledItemLike {
+  readonly provenance?: string | null;
+  readonly status?: string;
+}
+
+/**
+ * Compute the taint override for a recalled item set: untrusted when ANY
+ * item is quarantined or foreign-provenance; `undefined` when all items
+ * are first-party active (the common case - zero overhead, no override).
+ *
+ * @stable
+ */
+export function recallTaint(
+  items: ReadonlyArray<RecalledItemLike>,
+): { readonly untrusted: true; readonly sourceKind: 'memory-recall' } | undefined {
+  for (const item of items) {
+    if (item.status === 'quarantined' || isForeignProvenance(item.provenance)) {
+      return { untrusted: true, sourceKind: 'memory-recall' };
+    }
+  }
+  return undefined;
+}

package/src/tools/types.ts

@@ -0,0 +1,37 @@
+import type { SessionScope } from '@graphorin/core';
+import type { EpisodicMemory } from '../tiers/episodic-memory.js';
+import type { ProceduralMemory } from '../tiers/procedural-memory.js';
+import type { SemanticMemory } from '../tiers/semantic-memory.js';
+import type { SessionMemory } from '../tiers/session-memory.js';
+import type { SharedMemory } from '../tiers/shared-memory.js';
+import type { WorkingMemory } from '../tiers/working-memory.js';
+
+/**
+ * Resolver that produces the live {@link SessionScope} for the tool
+ * call from the surrounding agent run context. The agent runtime
+ * (Phase 12) supplies a closure that reads `RunContext` directly;
+ * standalone callers can pass a fixed scope.
+ *
+ * @stable
+ */
+export type ScopeResolver = (
+  ctx: import('@graphorin/core').ToolExecutionContext<unknown>,
+) => SessionScope | Promise<SessionScope>;
+
+/**
+ * Dependency bundle threaded into every memory tool. Exposed
+ * separately from the `Tool` surface so the executor can scope
+ * the dependencies per call without leaking the wider memory facade
+ * into the tool author surface.
+ *
+ * @stable
+ */
+export interface MemoryToolDeps {
+  readonly working: WorkingMemory;
+  readonly session: SessionMemory;
+  readonly episodic: EpisodicMemory;
+  readonly semantic: SemanticMemory;
+  readonly procedural: ProceduralMemory;
+  readonly shared: SharedMemory;
+  readonly resolveScope: ScopeResolver;
+}

package/dist/conflict/locale-packs/index.js

@@ -1,4 +0,0 @@
-import { defineLocalePack, evaluateMarkers } from "./types.js";
-import { enLocalePack } from "./en.js";
-
-export {  };

package/dist/context-engine/compaction/index.js

@@ -1,10 +0,0 @@
-import { CLEARED_TOOL_RESULT_MARKER, DEFAULT_KEEP_TOOL_USES, clearOldToolResults } from "./clear-tool-results.js";
-import { DEFAULT_SUMMARIZER_DUMP_CHAR_BUDGET, SUMMARY_TEMPLATE_NAME, SUMMARY_TEMPLATE_VERSION, buildSummarizerPrompt, renderFinalSummary } from "./templates/summary-9-section.js";
-import { DEFAULT_PRESERVE_RECENT_TURNS, executeCompaction } from "./compactor.js";
-import { reanchorPersonaBlock } from "./hooks/reanchor-persona-block.js";
-import { reanchorPinnedFacts } from "./hooks/reanchor-pinned-facts.js";
-import { reanchorProjectRules } from "./hooks/reanchor-project-rules.js";
-import { reanchorRecentResults } from "./hooks/reanchor-recent-results.js";
-import { DEFAULT_RESERVED_FOR_COMPACTION, DEFAULT_RESERVED_FOR_RESPONSE, DEFAULT_THRESHOLD_RATIO, resolveAutoCompactionDefault, resolveTriggerThreshold } from "./thresholds.js";
-
-export {  };

package/dist/context-engine/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/context-engine/index.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoJA;;;;;;;;UA/BiB,mBAAA;;;;;;;;;;;;wBAYO;;;;;;;UAQP,cAAA;;;wCAGuB;;;;;;;KAQ5B,YAAA,GAAY,gBAAA,CAA6B,YAAA"}

package/dist/context-engine/index.js

@@ -1,25 +0,0 @@
-import { CONTENT_ORIGIN_ATTR, INBOUND_TRUST_ATTR, NON_INBOUND_ORIGINS, annotate, shouldFireInboundPreamble, toSpanAttributes } from "./annotations.js";
-import { defaultLocaleHeuristicStrategy, defineAutoRecallStrategy } from "./auto-recall.js";
-import { HEURISTIC_TOKEN_COUNTER, adaptTokenCounter, countMessageTokens, renderMessageText } from "./token-counter.js";
-import { CLEARED_TOOL_RESULT_MARKER, DEFAULT_KEEP_TOOL_USES, clearOldToolResults } from "./compaction/clear-tool-results.js";
-import { DEFAULT_SUMMARIZER_DUMP_CHAR_BUDGET, SUMMARY_TEMPLATE_NAME, SUMMARY_TEMPLATE_VERSION, buildSummarizerPrompt, renderFinalSummary } from "./compaction/templates/summary-9-section.js";
-import { DEFAULT_PRESERVE_RECENT_TURNS, executeCompaction } from "./compaction/compactor.js";
-import { reanchorPersonaBlock } from "./compaction/hooks/reanchor-persona-block.js";
-import { reanchorPinnedFacts } from "./compaction/hooks/reanchor-pinned-facts.js";
-import { reanchorProjectRules } from "./compaction/hooks/reanchor-project-rules.js";
-import { reanchorRecentResults } from "./compaction/hooks/reanchor-recent-results.js";
-import { DEFAULT_RESERVED_FOR_COMPACTION, DEFAULT_RESERVED_FOR_RESPONSE, DEFAULT_THRESHOLD_RATIO, resolveAutoCompactionDefault, resolveTriggerThreshold } from "./compaction/thresholds.js";
-import "./compaction/index.js";
-import { enLocalePack } from "./locale-packs/en.js";
-import { defineContextLocalePack } from "./locale-packs/types.js";
-import "./locale-packs/index.js";
-import { _getLocaleFallbackWarningsForTesting, _resetLocaleFallbackWarningsForTesting, resolveLocalePack } from "./locale-packs/resolver.js";
-import { gatherMemoryMetadata, renderMetadataBlock } from "./metadata.js";
-import { decide, effectiveAcceptsSensitivity, partition } from "./privacy-filter.js";
-import { composeInboundPreamble, composeLayer1, composeLayer2, composeLayer4Skills } from "./templates/composer.js";
-import { DEFAULT_LAYER_PRIORITY, allocate, truncateToTokens } from "./token-budget.js";
-import { createContextEngine } from "./engine.js";
-import { INBOUND_SANITIZATION_PREAMBLE_EN } from "./preambles/inbound-en.js";
-import { BASE_TEMPLATE_EN_FULL, BASE_TEMPLATE_EN_MINIMAL } from "./templates/base-en.js";
-
-export {  };

package/dist/context-engine/locale-packs/index.js

@@ -1,4 +0,0 @@
-import { enLocalePack } from "./en.js";
-import { defineContextLocalePack } from "./types.js";
-
-export {  };