@graphorin/memory 0.5.0

package/dist/context-engine/locale-packs/types.d.ts

@@ -0,0 +1,119 @@
+//#region src/context-engine/locale-packs/types.d.ts
+/**
+ * Public types for the per-locale assets the
+ * {@link ContextEngine} consumes when assembling the layered system
+ * prompt. The framework ships an English default ({@link enLocalePack});
+ * additional locales are supplied by application code via
+ * {@link defineContextLocalePack}.
+ *
+ * The framework is locale-agnostic — no language is privileged in
+ * core. Every consumer-facing string is reachable through this
+ * surface so consumers can swap them without forking the framework.
+ *
+ * @packageDocumentation
+ */
+/**
+ * Trigger mode used by the auto-recall heuristic. The framework ships
+ * regex patterns for the bundled locale; consumers may extend or
+ * replace them via {@link defineContextLocalePack}.
+ *
+ * @stable
+ */
+interface AutoRecallTriggers {
+  /**
+   * Case-insensitive regex set evaluated against the last user
+   * message. A match indicates the model would benefit from the
+   * top-K facts being injected into Layer 6.
+   */
+  readonly factTriggers: ReadonlyArray<RegExp>;
+}
+/**
+ * Layer 1 template fragments. The {@link composeTemplate} function
+ * picks the right fragment based on `memoryBaseMode`.
+ *
+ * @stable
+ */
+interface BaseTemplateFragments {
+  /** Full educational template (~250-350 tokens). */
+  readonly full: string;
+  /** Minimal template for high-end models (~80-120 tokens). */
+  readonly minimal: string;
+}
+/**
+ * D4 inbound-sanitization preamble fragment. Injected after the
+ * cache breakpoint (Layer 5/6 territory) on steps containing
+ * untrusted tool output.
+ *
+ * @stable
+ */
+interface InboundSanitizationPreamble {
+  /** Verbatim text appended to the system message when fired. */
+  readonly text: string;
+}
+/**
+ * Structured 9-section summary template fragments used by the
+ * auto-compaction summarizer (RB-46). Section order is fixed; only
+ * the per-section header / preamble text is locale-extensible.
+ *
+ * Each entry is the human-readable header for the corresponding
+ * section. Section indices are 1-based to match the documented
+ * 9-section layout in the architecture doc.
+ *
+ * @stable
+ */
+interface CompactionSummaryTemplate {
+  /** Preamble injected at the top of the summarizer prompt. */
+  readonly preamble: string;
+  /** 11 section headers. The last two are filled by the harness. */
+  readonly sections: readonly [string, string, string, string, string, string, string, string, string, string, string];
+}
+/**
+ * A `LocalePack` collects every consumer-facing string the
+ * ContextEngine renders. Consumers register additional locales via
+ * {@link defineContextLocalePack}. The framework is locale-agnostic
+ * — no language is privileged in core.
+ *
+ * @stable
+ */
+interface ContextLocalePack {
+  /** Stable lowercase identifier (`'en'`, `'de'`, `'fr'`, …). */
+  readonly id: string;
+  /** Layer 1 base template fragments. */
+  readonly baseTemplate: BaseTemplateFragments;
+  /** Auto-recall trigger regex set. */
+  readonly autoRecallTriggers: AutoRecallTriggers;
+  /** Inbound-sanitization preamble (D4 — RB-43). */
+  readonly inboundSanitizationPreamble: InboundSanitizationPreamble;
+  /** 9-section compaction summary template (RB-46). */
+  readonly compactionSummaryTemplate: CompactionSummaryTemplate;
+}
+/**
+ * Builder used by application code that wants to ship a custom
+ * locale pack. The builder freezes every input so the pack can be
+ * safely reused across multiple `Memory` instances without
+ * accidental mutation.
+ *
+ * Partial packs are accepted: any field omitted falls back to the
+ * English default at compose time, with a one-time WARN per locale
+ * per missing surface (the safety guarantee is preserved even when
+ * an operator installs a partial locale pack).
+ *
+ * @stable
+ */
+interface PartialContextLocalePack {
+  readonly id: string;
+  readonly baseTemplate?: Partial<BaseTemplateFragments>;
+  readonly autoRecallTriggers?: Partial<AutoRecallTriggers>;
+  readonly inboundSanitizationPreamble?: Partial<InboundSanitizationPreamble>;
+  readonly compactionSummaryTemplate?: Partial<CompactionSummaryTemplate>;
+}
+/**
+ * Build a {@link ContextLocalePack} from a partial input. Missing
+ * fields fall back to the English default at compose time.
+ *
+ * @stable
+ */
+declare function defineContextLocalePack(input: PartialContextLocalePack): PartialContextLocalePack;
+//#endregion
+export { AutoRecallTriggers, BaseTemplateFragments, CompactionSummaryTemplate, ContextLocalePack, InboundSanitizationPreamble, PartialContextLocalePack, defineContextLocalePack };
+//# sourceMappingURL=types.d.ts.map

package/dist/context-engine/locale-packs/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","names":[],"sources":["../../../src/context-engine/locale-packs/types.ts"],"sourcesContent":[],"mappings":";;AAqBA;AAeA;AAcA;AAgBA;AA2BA;;;;;;AA0BA;;;;;;;;;AAK8C,UAvG7B,kBAAA,CAuG6B;EAS9B;;;;;yBA1GS,cAAc;;;;;;;;UAStB,qBAAA;;;;;;;;;;;;;UAcA,2BAAA;;;;;;;;;;;;;;;UAgBA,yBAAA;;;;;;;;;;;;;;UA2BA,iBAAA;;;;yBAIQ;;+BAEM;;wCAES;;sCAEF;;;;;;;;;;;;;;;UAgBrB,wBAAA;;0BAES,QAAQ;gCACF,QAAQ;yCACC,QAAQ;uCACV,QAAQ;;;;;;;;iBAS/B,uBAAA,QAA+B,2BAA2B"}

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

@@ -0,0 +1,24 @@
+//#region src/context-engine/locale-packs/types.ts
+/**
+* Build a {@link ContextLocalePack} from a partial input. Missing
+* fields fall back to the English default at compose time.
+*
+* @stable
+*/
+function defineContextLocalePack(input) {
+	if (typeof input.id !== "string" || input.id.length === 0) throw new TypeError("[graphorin/memory] defineContextLocalePack: `id` must be a non-empty lowercase string.");
+	return Object.freeze({
+		id: input.id,
+		...input.baseTemplate !== void 0 ? { baseTemplate: Object.freeze({ ...input.baseTemplate }) } : {},
+		...input.autoRecallTriggers !== void 0 ? { autoRecallTriggers: Object.freeze({ ...input.autoRecallTriggers.factTriggers !== void 0 ? { factTriggers: Object.freeze([...input.autoRecallTriggers.factTriggers]) } : {} }) } : {},
+		...input.inboundSanitizationPreamble !== void 0 ? { inboundSanitizationPreamble: Object.freeze({ ...input.inboundSanitizationPreamble }) } : {},
+		...input.compactionSummaryTemplate !== void 0 ? { compactionSummaryTemplate: Object.freeze({
+			...input.compactionSummaryTemplate.preamble !== void 0 ? { preamble: input.compactionSummaryTemplate.preamble } : {},
+			...input.compactionSummaryTemplate.sections !== void 0 ? { sections: Object.freeze([...input.compactionSummaryTemplate.sections]) } : {}
+		}) } : {}
+	});
+}
+
+//#endregion
+export { defineContextLocalePack };
+//# sourceMappingURL=types.js.map

package/dist/context-engine/locale-packs/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","names":[],"sources":["../../../src/context-engine/locale-packs/types.ts"],"sourcesContent":["/**\n * Public types for the per-locale assets the\n * {@link ContextEngine} consumes when assembling the layered system\n * prompt. The framework ships an English default ({@link enLocalePack});\n * additional locales are supplied by application code via\n * {@link defineContextLocalePack}.\n *\n * The framework is locale-agnostic — no language is privileged in\n * core. Every consumer-facing string is reachable through this\n * surface so consumers can swap them without forking the framework.\n *\n * @packageDocumentation\n */\n\n/**\n * Trigger mode used by the auto-recall heuristic. The framework ships\n * regex patterns for the bundled locale; consumers may extend or\n * replace them via {@link defineContextLocalePack}.\n *\n * @stable\n */\nexport interface AutoRecallTriggers {\n  /**\n   * Case-insensitive regex set evaluated against the last user\n   * message. A match indicates the model would benefit from the\n   * top-K facts being injected into Layer 6.\n   */\n  readonly factTriggers: ReadonlyArray<RegExp>;\n}\n\n/**\n * Layer 1 template fragments. The {@link composeTemplate} function\n * picks the right fragment based on `memoryBaseMode`.\n *\n * @stable\n */\nexport interface BaseTemplateFragments {\n  /** Full educational template (~250-350 tokens). */\n  readonly full: string;\n  /** Minimal template for high-end models (~80-120 tokens). */\n  readonly minimal: string;\n}\n\n/**\n * D4 inbound-sanitization preamble fragment. Injected after the\n * cache breakpoint (Layer 5/6 territory) on steps containing\n * untrusted tool output.\n *\n * @stable\n */\nexport interface InboundSanitizationPreamble {\n  /** Verbatim text appended to the system message when fired. */\n  readonly text: string;\n}\n\n/**\n * Structured 9-section summary template fragments used by the\n * auto-compaction summarizer (RB-46). Section order is fixed; only\n * the per-section header / preamble text is locale-extensible.\n *\n * Each entry is the human-readable header for the corresponding\n * section. Section indices are 1-based to match the documented\n * 9-section layout in the architecture doc.\n *\n * @stable\n */\nexport interface CompactionSummaryTemplate {\n  /** Preamble injected at the top of the summarizer prompt. */\n  readonly preamble: string;\n  /** 11 section headers. The last two are filled by the harness. */\n  readonly sections: readonly [\n    string, // 1: Session goal and current task\n    string, // 2: Decisions made and rationale\n    string, // 3: Key facts established\n    string, // 4: Open questions and ambiguities\n    string, // 5: Tools used and their outcomes\n    string, // 6: Files / artifacts referenced\n    string, // 7: Persona / preferences / project rules surfaced\n    string, // 8: Errors encountered and resolutions (SOTA-6)\n    string, // 9: Next steps (SOTA-6)\n    string, // 10: Recent turns preserved verbatim (harness-filled)\n    string, // 11: Compaction metadata (harness-filled)\n  ];\n}\n\n/**\n * A `LocalePack` collects every consumer-facing string the\n * ContextEngine renders. Consumers register additional locales via\n * {@link defineContextLocalePack}. The framework is locale-agnostic\n * — no language is privileged in core.\n *\n * @stable\n */\nexport interface ContextLocalePack {\n  /** Stable lowercase identifier (`'en'`, `'de'`, `'fr'`, …). */\n  readonly id: string;\n  /** Layer 1 base template fragments. */\n  readonly baseTemplate: BaseTemplateFragments;\n  /** Auto-recall trigger regex set. */\n  readonly autoRecallTriggers: AutoRecallTriggers;\n  /** Inbound-sanitization preamble (D4 — RB-43). */\n  readonly inboundSanitizationPreamble: InboundSanitizationPreamble;\n  /** 9-section compaction summary template (RB-46). */\n  readonly compactionSummaryTemplate: CompactionSummaryTemplate;\n}\n\n/**\n * Builder used by application code that wants to ship a custom\n * locale pack. The builder freezes every input so the pack can be\n * safely reused across multiple `Memory` instances without\n * accidental mutation.\n *\n * Partial packs are accepted: any field omitted falls back to the\n * English default at compose time, with a one-time WARN per locale\n * per missing surface (the safety guarantee is preserved even when\n * an operator installs a partial locale pack).\n *\n * @stable\n */\nexport interface PartialContextLocalePack {\n  readonly id: string;\n  readonly baseTemplate?: Partial<BaseTemplateFragments>;\n  readonly autoRecallTriggers?: Partial<AutoRecallTriggers>;\n  readonly inboundSanitizationPreamble?: Partial<InboundSanitizationPreamble>;\n  readonly compactionSummaryTemplate?: Partial<CompactionSummaryTemplate>;\n}\n\n/**\n * Build a {@link ContextLocalePack} from a partial input. Missing\n * fields fall back to the English default at compose time.\n *\n * @stable\n */\nexport function defineContextLocalePack(input: PartialContextLocalePack): PartialContextLocalePack {\n  if (typeof input.id !== 'string' || input.id.length === 0) {\n    throw new TypeError(\n      '[graphorin/memory] defineContextLocalePack: `id` must be a non-empty lowercase string.',\n    );\n  }\n  return Object.freeze({\n    id: input.id,\n    ...(input.baseTemplate !== undefined\n      ? { baseTemplate: Object.freeze({ ...input.baseTemplate }) }\n      : {}),\n    ...(input.autoRecallTriggers !== undefined\n      ? {\n          autoRecallTriggers: Object.freeze({\n            ...(input.autoRecallTriggers.factTriggers !== undefined\n              ? { factTriggers: Object.freeze([...input.autoRecallTriggers.factTriggers]) }\n              : {}),\n          }) as Partial<AutoRecallTriggers>,\n        }\n      : {}),\n    ...(input.inboundSanitizationPreamble !== undefined\n      ? {\n          inboundSanitizationPreamble: Object.freeze({ ...input.inboundSanitizationPreamble }),\n        }\n      : {}),\n    ...(input.compactionSummaryTemplate !== undefined\n      ? {\n          compactionSummaryTemplate: Object.freeze({\n            ...(input.compactionSummaryTemplate.preamble !== undefined\n              ? { preamble: input.compactionSummaryTemplate.preamble }\n              : {}),\n            ...(input.compactionSummaryTemplate.sections !== undefined\n              ? {\n                  sections: Object.freeze([\n                    ...input.compactionSummaryTemplate.sections,\n                  ]) as CompactionSummaryTemplate['sections'],\n                }\n              : {}),\n          }) as Partial<CompactionSummaryTemplate>,\n        }\n      : {}),\n  });\n}\n"],"mappings":";;;;;;;AAqIA,SAAgB,wBAAwB,OAA2D;AACjG,KAAI,OAAO,MAAM,OAAO,YAAY,MAAM,GAAG,WAAW,EACtD,OAAM,IAAI,UACR,yFACD;AAEH,QAAO,OAAO,OAAO;EACnB,IAAI,MAAM;EACV,GAAI,MAAM,iBAAiB,SACvB,EAAE,cAAc,OAAO,OAAO,EAAE,GAAG,MAAM,cAAc,CAAC,EAAE,GAC1D,EAAE;EACN,GAAI,MAAM,uBAAuB,SAC7B,EACE,oBAAoB,OAAO,OAAO,EAChC,GAAI,MAAM,mBAAmB,iBAAiB,SAC1C,EAAE,cAAc,OAAO,OAAO,CAAC,GAAG,MAAM,mBAAmB,aAAa,CAAC,EAAE,GAC3E,EAAE,EACP,CAAC,EACH,GACD,EAAE;EACN,GAAI,MAAM,gCAAgC,SACtC,EACE,6BAA6B,OAAO,OAAO,EAAE,GAAG,MAAM,6BAA6B,CAAC,EACrF,GACD,EAAE;EACN,GAAI,MAAM,8BAA8B,SACpC,EACE,2BAA2B,OAAO,OAAO;GACvC,GAAI,MAAM,0BAA0B,aAAa,SAC7C,EAAE,UAAU,MAAM,0BAA0B,UAAU,GACtD,EAAE;GACN,GAAI,MAAM,0BAA0B,aAAa,SAC7C,EACE,UAAU,OAAO,OAAO,CACtB,GAAG,MAAM,0BAA0B,SACpC,CAAC,EACH,GACD,EAAE;GACP,CAAC,EACH,GACD,EAAE;EACP,CAAC"}

package/dist/context-engine/metadata.d.ts

@@ -0,0 +1,40 @@
+import { MemoryStoreAdapter } from "../internal/storage-adapter.js";
+import { Consolidator } from "../consolidator/runtime.js";
+import "../consolidator/index.js";
+import { MemoryMetadata, SessionScope } from "@graphorin/core";
+
+//#region src/context-engine/metadata.d.ts
+
+/**
+ * Per-call dependency surface. Mirrors the `Memory` facade fields
+ * the metadata gatherer needs without taking a hard dependency on
+ * the facade type itself (the facade and the gatherer are
+ * mutually-referenced through the engine).
+ *
+ * @stable
+ */
+interface MemoryMetadataDeps {
+  readonly store: MemoryStoreAdapter;
+  readonly consolidator: Consolidator;
+  readonly embedderId: () => string | null;
+  readonly localeId: string;
+  /** Optional free-form metadata tags surfaced through `MemoryMetadata.tags`. */
+  readonly tags?: ReadonlyArray<string>;
+}
+/**
+ * Build the {@link MemoryMetadata} block. Pure async — no side
+ * effects beyond the storage reads.
+ *
+ * @stable
+ */
+declare function gatherMemoryMetadata(scope: SessionScope, deps: MemoryMetadataDeps): Promise<MemoryMetadata>;
+/**
+ * Render the {@link MemoryMetadata} block as the `<memory_metadata>`
+ * XML fragment used inside Layer 5 of the layered system prompt.
+ *
+ * @stable
+ */
+declare function renderMetadataBlock(meta: MemoryMetadata): string;
+//#endregion
+export { MemoryMetadataDeps, gatherMemoryMetadata, renderMetadataBlock };
+//# sourceMappingURL=metadata.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"metadata.d.ts","names":[],"sources":["../../src/context-engine/metadata.ts"],"sourcesContent":[],"mappings":";;;;;;;AAoCA;;;;;;AA4DA;;UA3EiB,kBAAA;kBACC;yBACO;;;;kBAIP;;;;;;;;iBASI,oBAAA,QACb,oBACD,qBACL,QAAQ;;;;;;;iBAyDK,mBAAA,OAA0B"}

package/dist/context-engine/metadata.js

@@ -0,0 +1,66 @@
+//#region src/context-engine/metadata.ts
+/**
+* Build the {@link MemoryMetadata} block. Pure async — no side
+* effects beyond the storage reads.
+*
+* @stable
+*/
+async function gatherMemoryMetadata(scope, deps) {
+	const [blocks, rules, episodeCount, messageCount, factCount, status] = await Promise.all([
+		deps.store.working.list(scope),
+		deps.store.procedural.list(scope),
+		countOrZero(deps.store.episodic, scope),
+		countOrZero(deps.store.session, scope),
+		countOrZero(deps.store.semantic, scope),
+		deps.consolidator.status()
+	]);
+	const embedderId = deps.embedderId();
+	const tags = [...deps.tags !== void 0 ? [...deps.tags] : [], `locale:${deps.localeId}`];
+	if (embedderId !== null) tags.push(`embedder:${embedderId}`);
+	const meta = {
+		factCount,
+		episodeCount,
+		messageCount,
+		activeRuleCount: rules.filter((rule) => rule.status !== "quarantined").length,
+		workingBlockCount: blocks.length,
+		...status.lastRunAt !== void 0 ? { lastConsolidatedAt: status.lastRunAt } : {},
+		tags: Object.freeze(tags)
+	};
+	return Object.freeze(meta);
+}
+/**
+* Read a tier's `count(scope)` when the adapter exposes it (CE-5), degrading to
+* `0` for adapters that do not — honest, and never the old 0/1 probe.
+*/
+async function countOrZero(store, scope) {
+	if (typeof store.count !== "function") return 0;
+	try {
+		return await store.count(scope);
+	} catch {
+		return 0;
+	}
+}
+/**
+* Render the {@link MemoryMetadata} block as the `<memory_metadata>`
+* XML fragment used inside Layer 5 of the layered system prompt.
+*
+* @stable
+*/
+function renderMetadataBlock(meta) {
+	const lines = [
+		"<memory_metadata>",
+		`  Working blocks: ${meta.workingBlockCount}`,
+		`  Active rules: ${meta.activeRuleCount}`,
+		`  Indexed messages: ${meta.messageCount}`,
+		`  Episodes: ${meta.episodeCount}`,
+		`  Facts: ${meta.factCount}`
+	];
+	if (meta.lastConsolidatedAt !== void 0) lines.push(`  Last consolidation: ${meta.lastConsolidatedAt}`);
+	if (meta.tags !== void 0 && meta.tags.length > 0) lines.push(`  Tags: ${meta.tags.join(", ")}`);
+	lines.push("</memory_metadata>");
+	return lines.join("\n");
+}
+
+//#endregion
+export { gatherMemoryMetadata, renderMetadataBlock };
+//# sourceMappingURL=metadata.js.map

package/dist/context-engine/metadata.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"metadata.js","names":["tags: string[]","meta: MemoryMetadata"],"sources":["../../src/context-engine/metadata.ts"],"sourcesContent":["/**\n * `gatherMemoryMetadata(...)` — implements the\n * {@link Memory.metadata} surface for Phase 10d. Aggregates\n * per-tier counts + last-consolidation timestamps + active\n * embedder id + active locale.\n *\n * @packageDocumentation\n */\n\nimport type { MemoryMetadata, SessionScope } from '@graphorin/core';\nimport type { Consolidator } from '../consolidator/index.js';\nimport type { MemoryStoreAdapter } from '../internal/storage-adapter.js';\n\n/**\n * Per-call dependency surface. Mirrors the `Memory` facade fields\n * the metadata gatherer needs without taking a hard dependency on\n * the facade type itself (the facade and the gatherer are\n * mutually-referenced through the engine).\n *\n * @stable\n */\nexport interface MemoryMetadataDeps {\n  readonly store: MemoryStoreAdapter;\n  readonly consolidator: Consolidator;\n  readonly embedderId: () => string | null;\n  readonly localeId: string;\n  /** Optional free-form metadata tags surfaced through `MemoryMetadata.tags`. */\n  readonly tags?: ReadonlyArray<string>;\n}\n\n/**\n * Build the {@link MemoryMetadata} block. Pure async — no side\n * effects beyond the storage reads.\n *\n * @stable\n */\nexport async function gatherMemoryMetadata(\n  scope: SessionScope,\n  deps: MemoryMetadataDeps,\n): Promise<MemoryMetadata> {\n  // CE-5 / MST-6: real `COUNT(*)` surfaces per tier — the old\n  // `search({ query: '*', topK: 1 })` probe was capped at 1 and matched zero\n  // rows on real SQLite (`escapeFtsQuery('*')` tokenises to nothing), so a\n  // production deploy told the model \"Facts: 0\" regardless of content. Counts\n  // never materialise rows; `messageCount` no longer lists up to 1000 messages.\n  const [blocks, rules, episodeCount, messageCount, factCount, status] = await Promise.all([\n    deps.store.working.list(scope),\n    deps.store.procedural.list(scope),\n    countOrZero(deps.store.episodic, scope),\n    countOrZero(deps.store.session, scope),\n    countOrZero(deps.store.semantic, scope),\n    deps.consolidator.status(),\n  ]);\n  // The metadata block surfaces the embedder id + active locale so\n  // the model can reason about the available embeddings; both are\n  // informational tags exposed through the optional `tags` field.\n  const embedderId = deps.embedderId();\n  const baseTags = deps.tags !== undefined ? [...deps.tags] : [];\n  const tags: string[] = [...baseTags, `locale:${deps.localeId}`];\n  if (embedderId !== null) tags.push(`embedder:${embedderId}`);\n\n  const meta: MemoryMetadata = {\n    factCount,\n    episodeCount,\n    messageCount,\n    // MST-6: \"Active rules\" excludes still-quarantined (e.g. induced) rules.\n    activeRuleCount: rules.filter((rule) => rule.status !== 'quarantined').length,\n    workingBlockCount: blocks.length,\n    ...(status.lastRunAt !== undefined ? { lastConsolidatedAt: status.lastRunAt } : {}),\n    tags: Object.freeze(tags),\n  };\n  return Object.freeze(meta);\n}\n\n/**\n * Read a tier's `count(scope)` when the adapter exposes it (CE-5), degrading to\n * `0` for adapters that do not — honest, and never the old 0/1 probe.\n */\nasync function countOrZero(\n  store: { count?(scope: SessionScope): Promise<number> },\n  scope: SessionScope,\n): Promise<number> {\n  if (typeof store.count !== 'function') return 0;\n  try {\n    return await store.count(scope);\n  } catch {\n    return 0;\n  }\n}\n\n/**\n * Render the {@link MemoryMetadata} block as the `<memory_metadata>`\n * XML fragment used inside Layer 5 of the layered system prompt.\n *\n * @stable\n */\nexport function renderMetadataBlock(meta: MemoryMetadata): string {\n  const lines = [\n    '<memory_metadata>',\n    `  Working blocks: ${meta.workingBlockCount}`,\n    `  Active rules: ${meta.activeRuleCount}`,\n    `  Indexed messages: ${meta.messageCount}`,\n    `  Episodes: ${meta.episodeCount}`,\n    `  Facts: ${meta.factCount}`,\n  ];\n  if (meta.lastConsolidatedAt !== undefined) {\n    lines.push(`  Last consolidation: ${meta.lastConsolidatedAt}`);\n  }\n  if (meta.tags !== undefined && meta.tags.length > 0) {\n    lines.push(`  Tags: ${meta.tags.join(', ')}`);\n  }\n  lines.push('</memory_metadata>');\n  return lines.join('\\n');\n}\n"],"mappings":";;;;;;;AAoCA,eAAsB,qBACpB,OACA,MACyB;CAMzB,MAAM,CAAC,QAAQ,OAAO,cAAc,cAAc,WAAW,UAAU,MAAM,QAAQ,IAAI;EACvF,KAAK,MAAM,QAAQ,KAAK,MAAM;EAC9B,KAAK,MAAM,WAAW,KAAK,MAAM;EACjC,YAAY,KAAK,MAAM,UAAU,MAAM;EACvC,YAAY,KAAK,MAAM,SAAS,MAAM;EACtC,YAAY,KAAK,MAAM,UAAU,MAAM;EACvC,KAAK,aAAa,QAAQ;EAC3B,CAAC;CAIF,MAAM,aAAa,KAAK,YAAY;CAEpC,MAAMA,OAAiB,CAAC,GADP,KAAK,SAAS,SAAY,CAAC,GAAG,KAAK,KAAK,GAAG,EAAE,EACzB,UAAU,KAAK,WAAW;AAC/D,KAAI,eAAe,KAAM,MAAK,KAAK,YAAY,aAAa;CAE5D,MAAMC,OAAuB;EAC3B;EACA;EACA;EAEA,iBAAiB,MAAM,QAAQ,SAAS,KAAK,WAAW,cAAc,CAAC;EACvE,mBAAmB,OAAO;EAC1B,GAAI,OAAO,cAAc,SAAY,EAAE,oBAAoB,OAAO,WAAW,GAAG,EAAE;EAClF,MAAM,OAAO,OAAO,KAAK;EAC1B;AACD,QAAO,OAAO,OAAO,KAAK;;;;;;AAO5B,eAAe,YACb,OACA,OACiB;AACjB,KAAI,OAAO,MAAM,UAAU,WAAY,QAAO;AAC9C,KAAI;AACF,SAAO,MAAM,MAAM,MAAM,MAAM;SACzB;AACN,SAAO;;;;;;;;;AAUX,SAAgB,oBAAoB,MAA8B;CAChE,MAAM,QAAQ;EACZ;EACA,qBAAqB,KAAK;EAC1B,mBAAmB,KAAK;EACxB,uBAAuB,KAAK;EAC5B,eAAe,KAAK;EACpB,YAAY,KAAK;EAClB;AACD,KAAI,KAAK,uBAAuB,OAC9B,OAAM,KAAK,yBAAyB,KAAK,qBAAqB;AAEhE,KAAI,KAAK,SAAS,UAAa,KAAK,KAAK,SAAS,EAChD,OAAM,KAAK,WAAW,KAAK,KAAK,KAAK,KAAK,GAAG;AAE/C,OAAM,KAAK,qBAAqB;AAChC,QAAO,MAAM,KAAK,KAAK"}

package/dist/context-engine/preambles/inbound-en.d.ts

@@ -0,0 +1,20 @@
+//#region src/context-engine/preambles/inbound-en.d.ts
+/**
+ * Convenience re-export of the English D4 inbound-sanitization
+ * preamble. Lives at the documented path
+ * `@graphorin/memory/context-engine/preambles/inbound-en.ts` so
+ * Phase 12 (agent runtime) can import it directly when wiring
+ * the per-step preamble injection.
+ *
+ * The framework is locale-agnostic — additional preambles plug in
+ * through `defineContextLocalePack({ inboundSanitizationPreamble:
+ * { text } })`. A partial locale pack falls back to this English
+ * default with a one-time WARN per locale.
+ *
+ * @packageDocumentation
+ */
+/** English D4 preamble text (~80-120 tokens, cache-friendly). */
+declare const INBOUND_SANITIZATION_PREAMBLE_EN: string;
+//#endregion
+export { INBOUND_SANITIZATION_PREAMBLE_EN };
+//# sourceMappingURL=inbound-en.d.ts.map

package/dist/context-engine/preambles/inbound-en.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inbound-en.d.ts","names":[],"sources":["../../../src/context-engine/preambles/inbound-en.ts"],"sourcesContent":[],"mappings":";;AAkBA;;;;;;;;;;;;;;cAAa"}

package/dist/context-engine/preambles/inbound-en.js

@@ -0,0 +1,23 @@
+import { enLocalePack } from "../locale-packs/en.js";
+
+//#region src/context-engine/preambles/inbound-en.ts
+/**
+* Convenience re-export of the English D4 inbound-sanitization
+* preamble. Lives at the documented path
+* `@graphorin/memory/context-engine/preambles/inbound-en.ts` so
+* Phase 12 (agent runtime) can import it directly when wiring
+* the per-step preamble injection.
+*
+* The framework is locale-agnostic — additional preambles plug in
+* through `defineContextLocalePack({ inboundSanitizationPreamble:
+* { text } })`. A partial locale pack falls back to this English
+* default with a one-time WARN per locale.
+*
+* @packageDocumentation
+*/
+/** English D4 preamble text (~80-120 tokens, cache-friendly). */
+const INBOUND_SANITIZATION_PREAMBLE_EN = enLocalePack.inboundSanitizationPreamble.text;
+
+//#endregion
+export { INBOUND_SANITIZATION_PREAMBLE_EN };
+//# sourceMappingURL=inbound-en.js.map

package/dist/context-engine/preambles/inbound-en.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"inbound-en.js","names":[],"sources":["../../../src/context-engine/preambles/inbound-en.ts"],"sourcesContent":["/**\n * Convenience re-export of the English D4 inbound-sanitization\n * preamble. Lives at the documented path\n * `@graphorin/memory/context-engine/preambles/inbound-en.ts` so\n * Phase 12 (agent runtime) can import it directly when wiring\n * the per-step preamble injection.\n *\n * The framework is locale-agnostic — additional preambles plug in\n * through `defineContextLocalePack({ inboundSanitizationPreamble:\n * { text } })`. A partial locale pack falls back to this English\n * default with a one-time WARN per locale.\n *\n * @packageDocumentation\n */\n\nimport { enLocalePack } from '../locale-packs/en.js';\n\n/** English D4 preamble text (~80-120 tokens, cache-friendly). */\nexport const INBOUND_SANITIZATION_PREAMBLE_EN = enLocalePack.inboundSanitizationPreamble.text;\n"],"mappings":";;;;;;;;;;;;;;;;;;AAkBA,MAAa,mCAAmC,aAAa,4BAA4B"}

package/dist/context-engine/privacy-filter.d.ts

@@ -0,0 +1,108 @@
+import { LocalProviderTrust, Sensitivity } from "@graphorin/core";
+
+//#region src/context-engine/privacy-filter.d.ts
+
+/**
+ * Filter input: the record-level sensitivity tag + the per-tier
+ * trust class of the active provider.
+ *
+ * @stable
+ */
+interface PrivacyFilterContext {
+  /**
+   * Sensitivity tiers the active provider is allowed to receive.
+   * When omitted, the per-tier defaults below apply.
+   */
+  readonly providerAcceptsSensitivity?: ReadonlyArray<Sensitivity>;
+  /**
+   * Trust class of the active provider as classified by
+   * `@graphorin/provider/trust/classify-local-provider.ts`. Defaults
+   * to `'public-tls'` (the conservative cloud default).
+   */
+  readonly providerTrust?: LocalProviderTrust;
+  /**
+   * Per-user opt-in for cloud upload of `'internal'`-tier content.
+   * Default `false` — `'internal'` content does not leave the
+   * loopback boundary unless the user explicitly opts in.
+   */
+  readonly cloudUploadConsent?: boolean;
+  /**
+   * Override the default sensitivity applied to records that are
+   * missing a tag. Default `'internal'` per DEC-126.
+   */
+  readonly defaultSensitivity?: Sensitivity;
+}
+/**
+ * Output of {@link decide} for a single record.
+ *
+ * @stable
+ */
+type PrivacyDecision = 'pass' | 'drop';
+/**
+ * Reason the decision was made. Surfaced to the metadata block so
+ * operators can audit per-tier drops.
+ *
+ * @stable
+ */
+type PrivacyDecisionReason = 'provider-rejects-secret' | 'provider-rejects-internal' | 'no-cloud-upload-consent' | 'allowed';
+/**
+ * Resolve the effective `acceptsSensitivity` set for a provider.
+ * The function is pure: callers can supply a custom matrix to
+ * override the defaults (used by tests + custom adapters).
+ *
+ * Defaults (DEC-149, ADR-013 ext):
+ *
+ * - `'loopback'`  → `['public', 'internal', 'secret']`.
+ * - `'private'`   → `['public', 'internal']`.
+ * - `'public-tls'` / `'public-mtls'` → `['public']`.
+ * - `'public-cleartext'` → `['public']`.
+ *
+ * Per-provider overrides always win over the defaults — pass
+ * `providerAcceptsSensitivity` explicitly to override.
+ *
+ * @stable
+ */
+declare function effectiveAcceptsSensitivity(context: PrivacyFilterContext): ReadonlyArray<Sensitivity>;
+/**
+ * Decide whether a single record is safe to send to the active
+ * provider. The decision logic mirrors the DoD spec:
+ *
+ * - `'public'` always passes.
+ * - `'secret'` passes only when the provider explicitly accepts
+ *   `'secret'` AND the trust class is `'loopback'`.
+ * - `'internal'` passes when the provider accepts `'internal'`
+ *   AND `cloudUploadConsent === true` (or the trust class is
+ *   `'loopback'` / `'private'`).
+ *
+ * @stable
+ */
+declare function decide(recordSensitivity: Sensitivity | undefined, context: PrivacyFilterContext): {
+  readonly decision: PrivacyDecision;
+  readonly reason: PrivacyDecisionReason;
+};
+/**
+ * Bookkeeping returned by {@link partition}. Carries both the
+ * surviving + dropped records and a per-reason counter for the
+ * audit trail.
+ *
+ * @stable
+ */
+interface PartitionResult<TRecord> {
+  readonly kept: ReadonlyArray<TRecord>;
+  readonly dropped: ReadonlyArray<{
+    readonly record: TRecord;
+    readonly reason: PrivacyDecisionReason;
+  }>;
+  readonly counters: Readonly<Record<PrivacyDecisionReason, number>>;
+}
+/**
+ * Partition a record list against the supplied filter context.
+ *
+ * @stable
+ */
+declare function partition<TRecord extends {
+  readonly sensitivity?: Sensitivity;
+}>(records: ReadonlyArray<TRecord>, context: PrivacyFilterContext): PartitionResult<TRecord>;
+//#endregion
+export { PartitionResult, PrivacyDecision, PrivacyDecisionReason, PrivacyFilterContext, decide, effectiveAcceptsSensitivity, partition };
+//# sourceMappingURL=privacy-filter.d.ts.map

package/dist/context-engine/privacy-filter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"privacy-filter.d.ts","names":[],"sources":["../../src/context-engine/privacy-filter.ts"],"sourcesContent":[],"mappings":";;;;;;;AAkHA;;;AAGwB,UAhGP,oBAAA,CAgGO;EAAkC;;AAiC1D;;EACiB,SAAA,0BAAA,CAAA,EA7HuB,aA6HvB,CA7HqC,WA6HrC,CAAA;EAEI;;;;;EAGA,SAAA,aAAA,CAAA,EA5HM,kBA4HN;EAAQ;AAQ7B;;;;EAEW,SAAA,kBAAA,CAAA,EAAA,OAAA;EACQ;;;;gCA5Ha;;;;;;;KAQpB,eAAA;;;;;;;KAQA,qBAAA;;;;;;;;;;;;;;;;;;iBAuBI,2BAAA,UACL,uBACR,cAAc;;;;;;;;;;;;;;iBA8BD,MAAA,oBACK,kCACV;qBACa;mBAAkC;;;;;;;;;UAiCzC;iBACA,cAAc;oBACX;qBACC;qBACA;;qBAEA,SAAS,OAAO;;;;;;;iBAQrB;yBAAmD;YACxD,cAAc,mBACd,uBACR,gBAAgB"}

package/dist/context-engine/privacy-filter.js

@@ -0,0 +1,113 @@
+//#region src/context-engine/privacy-filter.ts
+/**
+* Resolve the effective `acceptsSensitivity` set for a provider.
+* The function is pure: callers can supply a custom matrix to
+* override the defaults (used by tests + custom adapters).
+*
+* Defaults (DEC-149, ADR-013 ext):
+*
+* - `'loopback'`  → `['public', 'internal', 'secret']`.
+* - `'private'`   → `['public', 'internal']`.
+* - `'public-tls'` / `'public-mtls'` → `['public']`.
+* - `'public-cleartext'` → `['public']`.
+*
+* Per-provider overrides always win over the defaults — pass
+* `providerAcceptsSensitivity` explicitly to override.
+*
+* @stable
+*/
+function effectiveAcceptsSensitivity(context) {
+	if (context.providerAcceptsSensitivity !== void 0) return context.providerAcceptsSensitivity;
+	switch (context.providerTrust ?? "public-tls") {
+		case "loopback": return [
+			"public",
+			"internal",
+			"secret"
+		];
+		case "private": return ["public", "internal"];
+		case "public-tls":
+		case "public-cleartext": return ["public"];
+		default: return ["public"];
+	}
+}
+/**
+* Decide whether a single record is safe to send to the active
+* provider. The decision logic mirrors the DoD spec:
+*
+* - `'public'` always passes.
+* - `'secret'` passes only when the provider explicitly accepts
+*   `'secret'` AND the trust class is `'loopback'`.
+* - `'internal'` passes when the provider accepts `'internal'`
+*   AND `cloudUploadConsent === true` (or the trust class is
+*   `'loopback'` / `'private'`).
+*
+* @stable
+*/
+function decide(recordSensitivity, context) {
+	const sensitivity = recordSensitivity ?? context.defaultSensitivity ?? "internal";
+	const accepts = effectiveAcceptsSensitivity(context);
+	const trust = context.providerTrust ?? "public-tls";
+	if (sensitivity === "public") return {
+		decision: "pass",
+		reason: "allowed"
+	};
+	if (sensitivity === "secret") {
+		if (accepts.includes("secret") && trust === "loopback") return {
+			decision: "pass",
+			reason: "allowed"
+		};
+		return {
+			decision: "drop",
+			reason: "provider-rejects-secret"
+		};
+	}
+	if (!accepts.includes("internal")) return {
+		decision: "drop",
+		reason: "provider-rejects-internal"
+	};
+	if (trust === "loopback" || trust === "private") return {
+		decision: "pass",
+		reason: "allowed"
+	};
+	if (context.cloudUploadConsent === true) return {
+		decision: "pass",
+		reason: "allowed"
+	};
+	return {
+		decision: "drop",
+		reason: "no-cloud-upload-consent"
+	};
+}
+/**
+* Partition a record list against the supplied filter context.
+*
+* @stable
+*/
+function partition(records, context) {
+	const kept = [];
+	const dropped = [];
+	const counters = {
+		allowed: 0,
+		"no-cloud-upload-consent": 0,
+		"provider-rejects-internal": 0,
+		"provider-rejects-secret": 0
+	};
+	for (const record of records) {
+		const outcome = decide(record.sensitivity, context);
+		counters[outcome.reason] += 1;
+		if (outcome.decision === "pass") kept.push(record);
+		else dropped.push({
+			record,
+			reason: outcome.reason
+		});
+	}
+	return Object.freeze({
+		kept: Object.freeze(kept),
+		dropped: Object.freeze(dropped),
+		counters: Object.freeze(counters)
+	});
+}
+
+//#endregion
+export { decide, effectiveAcceptsSensitivity, partition };
+//# sourceMappingURL=privacy-filter.js.map

package/dist/context-engine/privacy-filter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"privacy-filter.js","names":["kept: TRecord[]","dropped: Array<{ readonly record: TRecord; readonly reason: PrivacyDecisionReason }>","counters: Record<PrivacyDecisionReason, number>"],"sources":["../../src/context-engine/privacy-filter.ts"],"sourcesContent":["/**\n * D2 sensitivity-tier filter. Tags every memory record with a\n * decision (`'pass'` / `'drop'`) before the assembled prompt is\n * compiled. The filter is *tier-based* — it trusts the\n * `record.sensitivity` tag the consolidator / writer set; the\n * outbound prompt-redaction middleware (D3, ADR-045) is the\n * universal backstop for content the filter cannot see (raw user\n * input, tool results, MCP responses, skill bodies, agent\n * instructions, tool-call args).\n *\n * @packageDocumentation\n */\n\nimport type { LocalProviderTrust, Sensitivity } from '@graphorin/core';\n\n/**\n * Filter input: the record-level sensitivity tag + the per-tier\n * trust class of the active provider.\n *\n * @stable\n */\nexport interface PrivacyFilterContext {\n  /**\n   * Sensitivity tiers the active provider is allowed to receive.\n   * When omitted, the per-tier defaults below apply.\n   */\n  readonly providerAcceptsSensitivity?: ReadonlyArray<Sensitivity>;\n  /**\n   * Trust class of the active provider as classified by\n   * `@graphorin/provider/trust/classify-local-provider.ts`. Defaults\n   * to `'public-tls'` (the conservative cloud default).\n   */\n  readonly providerTrust?: LocalProviderTrust;\n  /**\n   * Per-user opt-in for cloud upload of `'internal'`-tier content.\n   * Default `false` — `'internal'` content does not leave the\n   * loopback boundary unless the user explicitly opts in.\n   */\n  readonly cloudUploadConsent?: boolean;\n  /**\n   * Override the default sensitivity applied to records that are\n   * missing a tag. Default `'internal'` per DEC-126.\n   */\n  readonly defaultSensitivity?: Sensitivity;\n}\n\n/**\n * Output of {@link decide} for a single record.\n *\n * @stable\n */\nexport type PrivacyDecision = 'pass' | 'drop';\n\n/**\n * Reason the decision was made. Surfaced to the metadata block so\n * operators can audit per-tier drops.\n *\n * @stable\n */\nexport type PrivacyDecisionReason =\n  | 'provider-rejects-secret'\n  | 'provider-rejects-internal'\n  | 'no-cloud-upload-consent'\n  | 'allowed';\n\n/**\n * Resolve the effective `acceptsSensitivity` set for a provider.\n * The function is pure: callers can supply a custom matrix to\n * override the defaults (used by tests + custom adapters).\n *\n * Defaults (DEC-149, ADR-013 ext):\n *\n * - `'loopback'`  → `['public', 'internal', 'secret']`.\n * - `'private'`   → `['public', 'internal']`.\n * - `'public-tls'` / `'public-mtls'` → `['public']`.\n * - `'public-cleartext'` → `['public']`.\n *\n * Per-provider overrides always win over the defaults — pass\n * `providerAcceptsSensitivity` explicitly to override.\n *\n * @stable\n */\nexport function effectiveAcceptsSensitivity(\n  context: PrivacyFilterContext,\n): ReadonlyArray<Sensitivity> {\n  if (context.providerAcceptsSensitivity !== undefined) {\n    return context.providerAcceptsSensitivity;\n  }\n  switch (context.providerTrust ?? 'public-tls') {\n    case 'loopback':\n      return ['public', 'internal', 'secret'];\n    case 'private':\n      return ['public', 'internal'];\n    case 'public-tls':\n    case 'public-cleartext':\n      return ['public'];\n    default:\n      return ['public'];\n  }\n}\n\n/**\n * Decide whether a single record is safe to send to the active\n * provider. The decision logic mirrors the DoD spec:\n *\n * - `'public'` always passes.\n * - `'secret'` passes only when the provider explicitly accepts\n *   `'secret'` AND the trust class is `'loopback'`.\n * - `'internal'` passes when the provider accepts `'internal'`\n *   AND `cloudUploadConsent === true` (or the trust class is\n *   `'loopback'` / `'private'`).\n *\n * @stable\n */\nexport function decide(\n  recordSensitivity: Sensitivity | undefined,\n  context: PrivacyFilterContext,\n): { readonly decision: PrivacyDecision; readonly reason: PrivacyDecisionReason } {\n  const sensitivity = recordSensitivity ?? context.defaultSensitivity ?? 'internal';\n  const accepts = effectiveAcceptsSensitivity(context);\n  const trust = context.providerTrust ?? 'public-tls';\n  if (sensitivity === 'public') {\n    return { decision: 'pass', reason: 'allowed' };\n  }\n  if (sensitivity === 'secret') {\n    if (accepts.includes('secret') && trust === 'loopback') {\n      return { decision: 'pass', reason: 'allowed' };\n    }\n    return { decision: 'drop', reason: 'provider-rejects-secret' };\n  }\n  // 'internal'\n  if (!accepts.includes('internal')) {\n    return { decision: 'drop', reason: 'provider-rejects-internal' };\n  }\n  if (trust === 'loopback' || trust === 'private') {\n    return { decision: 'pass', reason: 'allowed' };\n  }\n  if (context.cloudUploadConsent === true) {\n    return { decision: 'pass', reason: 'allowed' };\n  }\n  return { decision: 'drop', reason: 'no-cloud-upload-consent' };\n}\n\n/**\n * Bookkeeping returned by {@link partition}. Carries both the\n * surviving + dropped records and a per-reason counter for the\n * audit trail.\n *\n * @stable\n */\nexport interface PartitionResult<TRecord> {\n  readonly kept: ReadonlyArray<TRecord>;\n  readonly dropped: ReadonlyArray<{\n    readonly record: TRecord;\n    readonly reason: PrivacyDecisionReason;\n  }>;\n  readonly counters: Readonly<Record<PrivacyDecisionReason, number>>;\n}\n\n/**\n * Partition a record list against the supplied filter context.\n *\n * @stable\n */\nexport function partition<TRecord extends { readonly sensitivity?: Sensitivity }>(\n  records: ReadonlyArray<TRecord>,\n  context: PrivacyFilterContext,\n): PartitionResult<TRecord> {\n  const kept: TRecord[] = [];\n  const dropped: Array<{ readonly record: TRecord; readonly reason: PrivacyDecisionReason }> = [];\n  const counters: Record<PrivacyDecisionReason, number> = {\n    allowed: 0,\n    'no-cloud-upload-consent': 0,\n    'provider-rejects-internal': 0,\n    'provider-rejects-secret': 0,\n  };\n  for (const record of records) {\n    const outcome = decide(record.sensitivity, context);\n    counters[outcome.reason] += 1;\n    if (outcome.decision === 'pass') {\n      kept.push(record);\n    } else {\n      dropped.push({ record, reason: outcome.reason });\n    }\n  }\n  return Object.freeze({\n    kept: Object.freeze(kept),\n    dropped: Object.freeze(dropped),\n    counters: Object.freeze(counters),\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAkFA,SAAgB,4BACd,SAC4B;AAC5B,KAAI,QAAQ,+BAA+B,OACzC,QAAO,QAAQ;AAEjB,SAAQ,QAAQ,iBAAiB,cAAjC;EACE,KAAK,WACH,QAAO;GAAC;GAAU;GAAY;GAAS;EACzC,KAAK,UACH,QAAO,CAAC,UAAU,WAAW;EAC/B,KAAK;EACL,KAAK,mBACH,QAAO,CAAC,SAAS;EACnB,QACE,QAAO,CAAC,SAAS;;;;;;;;;;;;;;;;AAiBvB,SAAgB,OACd,mBACA,SACgF;CAChF,MAAM,cAAc,qBAAqB,QAAQ,sBAAsB;CACvE,MAAM,UAAU,4BAA4B,QAAQ;CACpD,MAAM,QAAQ,QAAQ,iBAAiB;AACvC,KAAI,gBAAgB,SAClB,QAAO;EAAE,UAAU;EAAQ,QAAQ;EAAW;AAEhD,KAAI,gBAAgB,UAAU;AAC5B,MAAI,QAAQ,SAAS,SAAS,IAAI,UAAU,WAC1C,QAAO;GAAE,UAAU;GAAQ,QAAQ;GAAW;AAEhD,SAAO;GAAE,UAAU;GAAQ,QAAQ;GAA2B;;AAGhE,KAAI,CAAC,QAAQ,SAAS,WAAW,CAC/B,QAAO;EAAE,UAAU;EAAQ,QAAQ;EAA6B;AAElE,KAAI,UAAU,cAAc,UAAU,UACpC,QAAO;EAAE,UAAU;EAAQ,QAAQ;EAAW;AAEhD,KAAI,QAAQ,uBAAuB,KACjC,QAAO;EAAE,UAAU;EAAQ,QAAQ;EAAW;AAEhD,QAAO;EAAE,UAAU;EAAQ,QAAQ;EAA2B;;;;;;;AAwBhE,SAAgB,UACd,SACA,SAC0B;CAC1B,MAAMA,OAAkB,EAAE;CAC1B,MAAMC,UAAuF,EAAE;CAC/F,MAAMC,WAAkD;EACtD,SAAS;EACT,2BAA2B;EAC3B,6BAA6B;EAC7B,2BAA2B;EAC5B;AACD,MAAK,MAAM,UAAU,SAAS;EAC5B,MAAM,UAAU,OAAO,OAAO,aAAa,QAAQ;AACnD,WAAS,QAAQ,WAAW;AAC5B,MAAI,QAAQ,aAAa,OACvB,MAAK,KAAK,OAAO;MAEjB,SAAQ,KAAK;GAAE;GAAQ,QAAQ,QAAQ;GAAQ,CAAC;;AAGpD,QAAO,OAAO,OAAO;EACnB,MAAM,OAAO,OAAO,KAAK;EACzB,SAAS,OAAO,OAAO,QAAQ;EAC/B,UAAU,OAAO,OAAO,SAAS;EAClC,CAAC"}

package/dist/context-engine/templates/base-en.d.ts

@@ -0,0 +1,19 @@
+//#region src/context-engine/templates/base-en.d.ts
+/**
+ * Convenience re-export of the English Layer 1 base-template
+ * fragments so call sites can import the bundled defaults without
+ * dragging the full locale pack.
+ *
+ * The framework is locale-agnostic — no language is privileged in
+ * core. Application code can register additional locales via
+ * `defineContextLocalePack`.
+ *
+ * @packageDocumentation
+ */
+/** English Layer 1 in `'full'` mode (~250-350 tokens). */
+declare const BASE_TEMPLATE_EN_FULL: string;
+/** English Layer 1 in `'minimal'` mode (~80-120 tokens). */
+declare const BASE_TEMPLATE_EN_MINIMAL: string;
+//#endregion
+export { BASE_TEMPLATE_EN_FULL, BASE_TEMPLATE_EN_MINIMAL };
+//# sourceMappingURL=base-en.d.ts.map

package/dist/context-engine/templates/base-en.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base-en.d.ts","names":[],"sources":["../../../src/context-engine/templates/base-en.ts"],"sourcesContent":[],"mappings":";;AAeA;AAGA;;;;;;;;;;cAHa;;cAGA"}

package/dist/context-engine/templates/base-en.js

@@ -0,0 +1,22 @@
+import { enLocalePack } from "../locale-packs/en.js";
+
+//#region src/context-engine/templates/base-en.ts
+/**
+* Convenience re-export of the English Layer 1 base-template
+* fragments so call sites can import the bundled defaults without
+* dragging the full locale pack.
+*
+* The framework is locale-agnostic — no language is privileged in
+* core. Application code can register additional locales via
+* `defineContextLocalePack`.
+*
+* @packageDocumentation
+*/
+/** English Layer 1 in `'full'` mode (~250-350 tokens). */
+const BASE_TEMPLATE_EN_FULL = enLocalePack.baseTemplate.full;
+/** English Layer 1 in `'minimal'` mode (~80-120 tokens). */
+const BASE_TEMPLATE_EN_MINIMAL = enLocalePack.baseTemplate.minimal;
+
+//#endregion
+export { BASE_TEMPLATE_EN_FULL, BASE_TEMPLATE_EN_MINIMAL };
+//# sourceMappingURL=base-en.js.map

package/dist/context-engine/templates/base-en.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"base-en.js","names":[],"sources":["../../../src/context-engine/templates/base-en.ts"],"sourcesContent":["/**\n * Convenience re-export of the English Layer 1 base-template\n * fragments so call sites can import the bundled defaults without\n * dragging the full locale pack.\n *\n * The framework is locale-agnostic — no language is privileged in\n * core. Application code can register additional locales via\n * `defineContextLocalePack`.\n *\n * @packageDocumentation\n */\n\nimport { enLocalePack } from '../locale-packs/en.js';\n\n/** English Layer 1 in `'full'` mode (~250-350 tokens). */\nexport const BASE_TEMPLATE_EN_FULL = enLocalePack.baseTemplate.full;\n\n/** English Layer 1 in `'minimal'` mode (~80-120 tokens). */\nexport const BASE_TEMPLATE_EN_MINIMAL = enLocalePack.baseTemplate.minimal;\n"],"mappings":";;;;;;;;;;;;;;;AAeA,MAAa,wBAAwB,aAAa,aAAa;;AAG/D,MAAa,2BAA2B,aAAa,aAAa"}