@remnic/core 9.3.733 → 9.3.735

package/src/capabilities.test.ts

@@ -5,8 +5,26 @@ import { parseConfig } from "./config.js";
 import {
   resolveCapabilities,
   resolveAccessSetupCapabilities,
+  resolveNamespaceCapabilities,
+  resolveQmdCapabilities,
+  resolveIdentityContinuityCapabilities,
+  resolveLocalLlmCapabilities,
+  resolveSecurityCapabilities,
+  resolveEvalCapabilities,
+  resolveUtilityLearningCapabilities,
+  resolveObjectiveStateCapabilities,
+  resolveCompressionCapabilities,
   type CapabilitySet,
   type AccessSetupCapabilitySet,
+  type NamespaceCapabilitySet,
+  type QmdCapabilitySet,
+  type IdentityContinuityCapabilitySet,
+  type LocalLlmCapabilitySet,
+  type SecurityCapabilitySet,
+  type EvalCapabilitySet,
+  type UtilityLearningCapabilitySet,
+  type ObjectiveStateCapabilitySet,
+  type CompressionCapabilitySet,
 } from "./capabilities.js";
 
 /**
@@ -646,3 +664,360 @@ test("resolveCreationMemoryCapabilities matches pre-migration config reads (pari
     }
   }
 });
+
+// ---------------------------------------------------------------------------
+// Namespace capability set parity tests (issue #1523 batch 5).
+//
+// Guard: resolveNamespaceCapabilities(config).namespaces must always equal
+// config.namespacesEnabled. The flag is a non-optional boolean so no default
+// coercion is needed.
+// ---------------------------------------------------------------------------
+
+test("resolveNamespaceCapabilities: namespaces === config.namespacesEnabled (parity)", () => {
+  const cases = [
+    { label: "on", overrides: { namespacesEnabled: true } },
+    { label: "off", overrides: { namespacesEnabled: false } },
+  ];
+
+  for (const { label, overrides } of cases) {
+    const config = parseConfig(overrides);
+    const caps = resolveNamespaceCapabilities(config);
+    assert.equal(
+      caps.namespaces,
+      config.namespacesEnabled,
+      `[${label}] caps.namespaces must equal config.namespacesEnabled`,
+    );
+  }
+});
+
+test("resolveNamespaceCapabilities: result is frozen", () => {
+  const config = parseConfig({ namespacesEnabled: true });
+  const caps = resolveNamespaceCapabilities(config);
+  assert.ok(Object.isFrozen(caps), "NamespaceCapabilitySet must be frozen");
+});
+
+// ---------------------------------------------------------------------------
+// QmdCapabilitySet — gate-parity tests (issue #1523 batch 6).
+//
+// Same invariant: every caps field must project from its `<field>Enabled`
+// config flag. All twelve flags are required booleans on PluginConfig (defaults
+// resolved at the parse boundary), so the projection is pure passthrough.
+// ---------------------------------------------------------------------------
+
+const QMD_FIELD_TO_FLAG: Record<keyof QmdCapabilitySet, string> = {
+  qmd: "qmdEnabled",
+  qmdTierMigration: "qmdTierMigrationEnabled",
+  qmdTierAutoBackfill: "qmdTierAutoBackfillEnabled",
+  qmdAutoEmbed: "qmdAutoEmbedEnabled",
+  qmdMaintenance: "qmdMaintenanceEnabled",
+  qmdColdTier: "qmdColdTierEnabled",
+  qmdDaemon: "qmdDaemonEnabled",
+  qmdTierParityGraph: "qmdTierParityGraphEnabled",
+  qmdQueryRerank: "qmdQueryRerankEnabled",
+  qmdIntentHints: "qmdIntentHintsEnabled",
+  qmdExplain: "qmdExplainEnabled",
+  qmdAutoUpgrade: "qmdAutoUpgradeEnabled",
+};
+
+const QMD_FIELDS = Object.keys(QMD_FIELD_TO_FLAG) as Array<keyof QmdCapabilitySet>;
+
+test("resolveQmdCapabilities projects every field from its flag (true variant)", () => {
+  const overrides: Record<string, boolean> = {};
+  for (const flag of Object.values(QMD_FIELD_TO_FLAG)) overrides[flag] = true;
+  const config = parseConfig(overrides);
+  const caps = resolveQmdCapabilities(config);
+
+  for (const field of QMD_FIELDS) {
+    const flag = QMD_FIELD_TO_FLAG[field];
+    assert.equal(caps[field], true, `caps.${field} must be true when ${flag}=true`);
+  }
+});
+
+test("resolveQmdCapabilities projects every field from its flag (false variant)", () => {
+  const overrides: Record<string, boolean> = {};
+  for (const flag of Object.values(QMD_FIELD_TO_FLAG)) overrides[flag] = false;
+  const config = parseConfig(overrides);
+  const caps = resolveQmdCapabilities(config);
+
+  for (const field of QMD_FIELDS) {
+    const flag = QMD_FIELD_TO_FLAG[field];
+    assert.equal(caps[field], false, `caps.${field} must be false when ${flag}=false`);
+  }
+});
+
+test("resolveQmdCapabilities returns a frozen object", () => {
+  const config = parseConfig({});
+  const caps = resolveQmdCapabilities(config);
+  assert.equal(Object.isFrozen(caps), true);
+});
+
+test("resolveQmdCapabilities matches pre-migration config reads (parity contract)", () => {
+  const cases: Record<string, Record<string, boolean>> = {
+    "all-off": Object.fromEntries(Object.values(QMD_FIELD_TO_FLAG).map((f) => [f, false])),
+    "all-on": Object.fromEntries(Object.values(QMD_FIELD_TO_FLAG).map((f) => [f, true])),
+    "qmd-on-rest-off": {
+      ...Object.fromEntries(Object.values(QMD_FIELD_TO_FLAG).map((f) => [f, false])),
+      qmdEnabled: true,
+    },
+    "tiers-on-qmd-off": {
+      ...Object.fromEntries(Object.values(QMD_FIELD_TO_FLAG).map((f) => [f, false])),
+      qmdTierMigrationEnabled: true,
+      qmdColdTierEnabled: true,
+    },
+  };
+
+  for (const [label, overrides] of Object.entries(cases)) {
+    const config = parseConfig(overrides);
+    const caps = resolveQmdCapabilities(config);
+
+    for (const field of QMD_FIELDS) {
+      const flag = QMD_FIELD_TO_FLAG[field];
+      assert.equal(
+        caps[field],
+        (config as unknown as Record<string, boolean>)[flag],
+        `[${label}] caps.${field} must equal config.${flag}`,
+      );
+    }
+  }
+});
+
+// ---------------------------------------------------------------------------
+// IdentityContinuityCapabilitySet — gate-parity tests (issue #1523 batch 6).
+// ---------------------------------------------------------------------------
+
+test("resolveIdentityContinuityCapabilities: identityContinuity === config.identityContinuityEnabled (parity)", () => {
+  const cases = [
+    { label: "on", overrides: { identityContinuityEnabled: true } },
+    { label: "off", overrides: { identityContinuityEnabled: false } },
+  ];
+
+  for (const { label, overrides } of cases) {
+    const config = parseConfig(overrides);
+    const caps = resolveIdentityContinuityCapabilities(config);
+    assert.equal(
+      caps.identityContinuity,
+      config.identityContinuityEnabled,
+      `[${label}] caps.identityContinuity must equal config.identityContinuityEnabled`,
+    );
+  }
+});
+
+test("resolveIdentityContinuityCapabilities: result is frozen", () => {
+  const config = parseConfig({ identityContinuityEnabled: true });
+  const caps = resolveIdentityContinuityCapabilities(config);
+  assert.ok(Object.isFrozen(caps), "IdentityContinuityCapabilitySet must be frozen");
+});
+
+// ---------------------------------------------------------------------------
+// LocalLlmCapabilitySet — gate-parity tests (issue #1523 batch 6).
+// ---------------------------------------------------------------------------
+
+test("resolveLocalLlmCapabilities: localLlm === config.localLlmEnabled (parity)", () => {
+  const cases = [
+    { label: "on", overrides: { localLlmEnabled: true } },
+    { label: "off", overrides: { localLlmEnabled: false } },
+  ];
+
+  for (const { label, overrides } of cases) {
+    const config = parseConfig(overrides);
+    const caps = resolveLocalLlmCapabilities(config);
+    assert.equal(
+      caps.localLlm,
+      config.localLlmEnabled,
+      `[${label}] caps.localLlm must equal config.localLlmEnabled`,
+    );
+  }
+});
+
+test("resolveLocalLlmCapabilities: result is frozen", () => {
+  const config = parseConfig({ localLlmEnabled: true });
+  const caps = resolveLocalLlmCapabilities(config);
+  assert.ok(Object.isFrozen(caps), "LocalLlmCapabilitySet must be frozen");
+});
+
+// ---------------------------------------------------------------------------
+// SecurityCapabilitySet — gate-parity tests (issue #1523 batch 7).
+// ---------------------------------------------------------------------------
+
+const SECURITY_FIELD_TO_FLAG: Record<keyof SecurityCapabilitySet, string> = {
+  trustZones: "trustZonesEnabled",
+  quarantinePromotion: "quarantinePromotionEnabled",
+  memoryPoisoningDefense: "memoryPoisoningDefenseEnabled",
+  trustZoneRecall: "trustZoneRecallEnabled",
+};
+
+const SECURITY_FIELDS = Object.keys(SECURITY_FIELD_TO_FLAG) as Array<keyof SecurityCapabilitySet>;
+
+test("resolveSecurityCapabilities projects every field from its flag (true variant)", () => {
+  const overrides: Record<string, boolean> = {};
+  for (const flag of Object.values(SECURITY_FIELD_TO_FLAG)) overrides[flag] = true;
+  const config = parseConfig(overrides);
+  const caps = resolveSecurityCapabilities(config);
+  for (const field of SECURITY_FIELDS) {
+    assert.equal(caps[field], true, `${field} must be true`);
+  }
+});
+
+test("resolveSecurityCapabilities projects every field from its flag (false variant)", () => {
+  const overrides: Record<string, boolean> = {};
+  for (const flag of Object.values(SECURITY_FIELD_TO_FLAG)) overrides[flag] = false;
+  const config = parseConfig(overrides);
+  const caps = resolveSecurityCapabilities(config);
+  for (const field of SECURITY_FIELDS) {
+    assert.equal(caps[field], false, `${field} must be false`);
+  }
+});
+
+test("resolveSecurityCapabilities returns a frozen object", () => {
+  const caps = resolveSecurityCapabilities(parseConfig({}));
+  assert.equal(Object.isFrozen(caps), true, "SecurityCapabilitySet must be frozen");
+});
+
+// ---------------------------------------------------------------------------
+// EvalCapabilitySet — gate-parity tests (issue #1523 batch 7).
+// ---------------------------------------------------------------------------
+
+const EVAL_FIELD_TO_FLAG: Record<keyof EvalCapabilitySet, string> = {
+  evalHarness: "evalHarnessEnabled",
+  evalShadowMode: "evalShadowModeEnabled",
+  benchmarkBaselineSnapshots: "benchmarkBaselineSnapshotsEnabled",
+  benchmarkDeltaReporter: "benchmarkDeltaReporterEnabled",
+  memoryRedTeamBench: "memoryRedTeamBenchEnabled",
+};
+
+const EVAL_FIELDS = Object.keys(EVAL_FIELD_TO_FLAG) as Array<keyof EvalCapabilitySet>;
+
+test("resolveEvalCapabilities projects every field from its flag (true variant)", () => {
+  const overrides: Record<string, boolean> = {};
+  for (const flag of Object.values(EVAL_FIELD_TO_FLAG)) overrides[flag] = true;
+  const config = parseConfig(overrides);
+  const caps = resolveEvalCapabilities(config);
+  for (const field of EVAL_FIELDS) {
+    assert.equal(caps[field], true, `${field} must be true`);
+  }
+});
+
+test("resolveEvalCapabilities projects every field from its flag (false variant)", () => {
+  const overrides: Record<string, boolean> = {};
+  for (const flag of Object.values(EVAL_FIELD_TO_FLAG)) overrides[flag] = false;
+  const config = parseConfig(overrides);
+  const caps = resolveEvalCapabilities(config);
+  for (const field of EVAL_FIELDS) {
+    assert.equal(caps[field], false, `${field} must be false`);
+  }
+});
+
+test("resolveEvalCapabilities returns a frozen object", () => {
+  const caps = resolveEvalCapabilities(parseConfig({}));
+  assert.equal(Object.isFrozen(caps), true, "EvalCapabilitySet must be frozen");
+});
+
+// ---------------------------------------------------------------------------
+// UtilityLearningCapabilitySet — gate-parity tests (issue #1523 batch 7).
+// ---------------------------------------------------------------------------
+
+const UTILITY_FIELD_TO_FLAG: Record<keyof UtilityLearningCapabilitySet, string> = {
+  memoryUtilityLearning: "memoryUtilityLearningEnabled",
+  promotionByOutcome: "promotionByOutcomeEnabled",
+};
+
+const UTILITY_FIELDS = Object.keys(UTILITY_FIELD_TO_FLAG) as Array<keyof UtilityLearningCapabilitySet>;
+
+test("resolveUtilityLearningCapabilities projects every field from its flag (true variant)", () => {
+  const overrides: Record<string, boolean> = {};
+  for (const flag of Object.values(UTILITY_FIELD_TO_FLAG)) overrides[flag] = true;
+  const config = parseConfig(overrides);
+  const caps = resolveUtilityLearningCapabilities(config);
+  for (const field of UTILITY_FIELDS) {
+    assert.equal(caps[field], true, `${field} must be true`);
+  }
+});
+
+test("resolveUtilityLearningCapabilities projects every field from its flag (false variant)", () => {
+  const overrides: Record<string, boolean> = {};
+  for (const flag of Object.values(UTILITY_FIELD_TO_FLAG)) overrides[flag] = false;
+  const config = parseConfig(overrides);
+  const caps = resolveUtilityLearningCapabilities(config);
+  for (const field of UTILITY_FIELDS) {
+    assert.equal(caps[field], false, `${field} must be false`);
+  }
+});
+
+test("resolveUtilityLearningCapabilities returns a frozen object", () => {
+  const caps = resolveUtilityLearningCapabilities(parseConfig({}));
+  assert.equal(Object.isFrozen(caps), true, "UtilityLearningCapabilitySet must be frozen");
+});
+
+// ---------------------------------------------------------------------------
+// ObjectiveStateCapabilitySet — gate-parity tests (issue #1523 batch 7).
+// ---------------------------------------------------------------------------
+
+const OBJECTIVE_FIELD_TO_FLAG: Record<keyof ObjectiveStateCapabilitySet, string> = {
+  objectiveStateMemory: "objectiveStateMemoryEnabled",
+  objectiveStateSnapshotWrites: "objectiveStateSnapshotWritesEnabled",
+  objectiveStateRecall: "objectiveStateRecallEnabled",
+};
+
+const OBJECTIVE_FIELDS = Object.keys(OBJECTIVE_FIELD_TO_FLAG) as Array<keyof ObjectiveStateCapabilitySet>;
+
+test("resolveObjectiveStateCapabilities projects every field from its flag (true variant)", () => {
+  const overrides: Record<string, boolean> = {};
+  for (const flag of Object.values(OBJECTIVE_FIELD_TO_FLAG)) overrides[flag] = true;
+  const config = parseConfig(overrides);
+  const caps = resolveObjectiveStateCapabilities(config);
+  for (const field of OBJECTIVE_FIELDS) {
+    assert.equal(caps[field], true, `${field} must be true`);
+  }
+});
+
+test("resolveObjectiveStateCapabilities projects every field from its flag (false variant)", () => {
+  const overrides: Record<string, boolean> = {};
+  for (const flag of Object.values(OBJECTIVE_FIELD_TO_FLAG)) overrides[flag] = false;
+  const config = parseConfig(overrides);
+  const caps = resolveObjectiveStateCapabilities(config);
+  for (const field of OBJECTIVE_FIELDS) {
+    assert.equal(caps[field], false, `${field} must be false`);
+  }
+});
+
+test("resolveObjectiveStateCapabilities returns a frozen object", () => {
+  const caps = resolveObjectiveStateCapabilities(parseConfig({}));
+  assert.equal(Object.isFrozen(caps), true, "ObjectiveStateCapabilitySet must be frozen");
+});
+
+// ---------------------------------------------------------------------------
+// CompressionCapabilitySet — gate-parity tests (issue #1523 batch 7).
+// ---------------------------------------------------------------------------
+
+const COMPRESSION_FIELD_TO_FLAG: Record<keyof CompressionCapabilitySet, string> = {
+  compressionGuidelineLearning: "compressionGuidelineLearningEnabled",
+  compressionGuidelineSemanticRefinement: "compressionGuidelineSemanticRefinementEnabled",
+  contextCompressionActions: "contextCompressionActionsEnabled",
+};
+
+const COMPRESSION_FIELDS = Object.keys(COMPRESSION_FIELD_TO_FLAG) as Array<keyof CompressionCapabilitySet>;
+
+test("resolveCompressionCapabilities projects every field from its flag (true variant)", () => {
+  const overrides: Record<string, boolean> = {};
+  for (const flag of Object.values(COMPRESSION_FIELD_TO_FLAG)) overrides[flag] = true;
+  const config = parseConfig(overrides);
+  const caps = resolveCompressionCapabilities(config);
+  for (const field of COMPRESSION_FIELDS) {
+    assert.equal(caps[field], true, `${field} must be true`);
+  }
+});
+
+test("resolveCompressionCapabilities projects every field from its flag (false variant)", () => {
+  const overrides: Record<string, boolean> = {};
+  for (const flag of Object.values(COMPRESSION_FIELD_TO_FLAG)) overrides[flag] = false;
+  const config = parseConfig(overrides);
+  const caps = resolveCompressionCapabilities(config);
+  for (const field of COMPRESSION_FIELDS) {
+    assert.equal(caps[field], false, `${field} must be false`);
+  }
+});
+
+test("resolveCompressionCapabilities returns a frozen object", () => {
+  const caps = resolveCompressionCapabilities(parseConfig({}));
+  assert.equal(Object.isFrozen(caps), true, "CompressionCapabilitySet must be frozen");
+});