@remnic/core 9.3.654 → 9.3.656

package/dist/{chunk-YLZLPVKK.js → chunk-CTAV55JM.js}

@@ -373,6 +373,228 @@ var LEGACY_ACTIVE_RECALL_CUSTOM_FIELD = [
   "Prompt",
   "Override"
 ].join("");
+var SCOPE_PROFILE_LAYER_IDS = [
+  "userProject",
+  "teamProject",
+  "userGlobal",
+  "serverShared"
+];
+var SCOPE_PROFILE_PROMOTION_TARGETS = [
+  ...SCOPE_PROFILE_LAYER_IDS
+];
+var SCOPE_PROFILE_AUTO_PROMOTE_CATEGORIES = [
+  "fact",
+  "correction",
+  "decision",
+  "preference",
+  "rule",
+  "procedure"
+];
+var CONFIDENCE_TIERS = [
+  "explicit",
+  "implied",
+  "inferred",
+  "speculative"
+];
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseStringList(value, keyName) {
+  if (value === void 0 || value === null) return [];
+  if (!Array.isArray(value)) {
+    throw new Error(keyName + " must be an array");
+  }
+  const out = [];
+  for (const entry of value) {
+    if (typeof entry !== "string" || entry.length === 0) {
+      throw new Error(keyName + " must contain only non-empty strings");
+    }
+    out.push(entry);
+  }
+  return out;
+}
+function parseScopeProfileLayerList(value, keyName, fallback) {
+  if (value === void 0 || value === null) return [...fallback];
+  if (!Array.isArray(value)) {
+    throw new Error(`${keyName} must be an array`);
+  }
+  const out = [];
+  for (const entry of value) {
+    if (!SCOPE_PROFILE_LAYER_IDS.includes(entry)) {
+      throw new Error(`${keyName} contains unsupported layer: ${String(entry)}`);
+    }
+    if (!out.includes(entry)) {
+      out.push(entry);
+    }
+  }
+  return out;
+}
+function parseScopeProfilePromotionTargets(value, keyName) {
+  if (value === void 0 || value === null) return [];
+  if (!Array.isArray(value)) {
+    throw new Error(`${keyName} must be an array`);
+  }
+  const out = [];
+  for (const entry of value) {
+    if (!SCOPE_PROFILE_PROMOTION_TARGETS.includes(entry)) {
+      throw new Error(`${keyName} contains unsupported target: ${String(entry)}`);
+    }
+    if (!out.includes(entry)) {
+      out.push(entry);
+    }
+  }
+  return out;
+}
+function parseScopeProfiles(value) {
+  if (value === void 0 || value === null) return {};
+  if (!isRecord(value)) {
+    throw new Error("scopeProfiles must be an object");
+  }
+  const profiles = {};
+  for (const [profileId, rawProfile] of Object.entries(value)) {
+    if (profileId.trim().length === 0) {
+      throw new Error("scopeProfiles keys must not be empty");
+    }
+    if (!isRecord(rawProfile)) {
+      throw new Error(`scopeProfiles.${profileId} must be an object`);
+    }
+    const readOrder = parseScopeProfileLayerList(
+      rawProfile.readOrder,
+      `scopeProfiles.${profileId}.readOrder`,
+      ["userProject", "userGlobal", "serverShared"]
+    );
+    const writeDefault = rawProfile.writeDefault === void 0 || rawProfile.writeDefault === null ? "userProject" : rawProfile.writeDefault;
+    if (!SCOPE_PROFILE_LAYER_IDS.includes(writeDefault)) {
+      throw new Error(`scopeProfiles.${profileId}.writeDefault contains unsupported layer: ${String(writeDefault)}`);
+    }
+    if (rawProfile.teamProject !== void 0 && rawProfile.teamProject !== null && !isRecord(rawProfile.teamProject)) {
+      throw new Error("scopeProfiles." + profileId + ".teamProject must be an object");
+    }
+    const teamProject = (() => {
+      if (!isRecord(rawProfile.teamProject)) return void 0;
+      const out = {};
+      if (rawProfile.teamProject.namespaceTemplate !== void 0) {
+        if (typeof rawProfile.teamProject.namespaceTemplate !== "string" || rawProfile.teamProject.namespaceTemplate.length === 0) {
+          throw new Error(
+            `scopeProfiles.${profileId}.teamProject.namespaceTemplate must be a non-empty string`
+          );
+        }
+        out.namespaceTemplate = rawProfile.teamProject.namespaceTemplate;
+      }
+      if (rawProfile.teamProject.teamId !== void 0) {
+        if (typeof rawProfile.teamProject.teamId !== "string" || rawProfile.teamProject.teamId.length === 0) {
+          throw new Error(
+            `scopeProfiles.${profileId}.teamProject.teamId must be a non-empty string`
+          );
+        }
+        out.teamId = rawProfile.teamProject.teamId;
+      }
+      return out;
+    })();
+    if (rawProfile.autoPromote !== void 0 && rawProfile.autoPromote !== null && !isRecord(rawProfile.autoPromote)) {
+      throw new Error(`scopeProfiles.${profileId}.autoPromote must be an object`);
+    }
+    const rawAutoPromote = isRecord(rawProfile.autoPromote) ? rawProfile.autoPromote : {};
+    const hasAutoPromoteEnabled = Object.prototype.hasOwnProperty.call(
+      rawAutoPromote,
+      "enabled"
+    );
+    const autoPromoteEnabled = coerceBool(rawAutoPromote.enabled);
+    if (hasAutoPromoteEnabled && autoPromoteEnabled === void 0) {
+      throw new Error(
+        `scopeProfiles.${profileId}.autoPromote.enabled must be a boolean or boolean-like string`
+      );
+    }
+    const minConfidenceTier = (() => {
+      const rawTier = rawAutoPromote.minConfidenceTier;
+      if (rawTier === void 0 || rawTier === null) return "explicit";
+      if (typeof rawTier !== "string" || !CONFIDENCE_TIERS.includes(rawTier)) {
+        throw new Error(
+          `scopeProfiles.${profileId}.autoPromote.minConfidenceTier must be one of: ${CONFIDENCE_TIERS.join(", ")}`
+        );
+      }
+      return rawTier;
+    })();
+    const autoPromoteCategories = (() => {
+      if (rawAutoPromote.categories === void 0 || rawAutoPromote.categories === null) {
+        return ["fact", "correction", "decision", "preference"];
+      }
+      if (!Array.isArray(rawAutoPromote.categories)) {
+        throw new Error(
+          `scopeProfiles.${profileId}.autoPromote.categories must be an array`
+        );
+      }
+      const categories = [];
+      for (const entry of rawAutoPromote.categories) {
+        if (typeof entry !== "string" || !SCOPE_PROFILE_AUTO_PROMOTE_CATEGORIES.includes(entry)) {
+          throw new Error(
+            "scopeProfiles." + profileId + ".autoPromote.categories must contain only: " + SCOPE_PROFILE_AUTO_PROMOTE_CATEGORIES.join(", ")
+          );
+        }
+        categories.push(entry);
+      }
+      return categories;
+    })();
+    profiles[profileId] = {
+      readOrder,
+      writeDefault,
+      promotionTargets: parseScopeProfilePromotionTargets(
+        rawProfile.promotionTargets,
+        `scopeProfiles.${profileId}.promotionTargets`
+      ),
+      ...teamProject && Object.keys(teamProject).length > 0 ? { teamProject } : {},
+      autoPromote: {
+        enabled: autoPromoteEnabled === true,
+        targets: parseScopeProfilePromotionTargets(
+          rawAutoPromote.targets,
+          `scopeProfiles.${profileId}.autoPromote.targets`
+        ),
+        categories: autoPromoteCategories,
+        minConfidenceTier
+      }
+    };
+  }
+  return profiles;
+}
+function parseScopeTeams(value) {
+  if (value === void 0 || value === null) return {};
+  if (!isRecord(value)) {
+    throw new Error("teams must be an object");
+  }
+  const teams = {};
+  for (const [teamId, rawTeam] of Object.entries(value)) {
+    if (teamId.trim().length === 0) {
+      throw new Error("teams keys must not be empty");
+    }
+    if (!isRecord(rawTeam)) {
+      throw new Error(`teams.${teamId} must be an object`);
+    }
+    const projectNamespaceTemplate = rawTeam.projectNamespaceTemplate;
+    if (projectNamespaceTemplate !== void 0) {
+      if (typeof projectNamespaceTemplate !== "string" || projectNamespaceTemplate.length === 0) {
+        throw new Error(`teams.${teamId}.projectNamespaceTemplate must be a non-empty string`);
+      }
+    }
+    teams[teamId] = {
+      principals: parseStringList(rawTeam.principals, `teams.${teamId}.principals`),
+      ...projectNamespaceTemplate !== void 0 ? { projectNamespaceTemplate } : {},
+      read: parseStringList(rawTeam.read, `teams.${teamId}.read`),
+      write: parseStringList(rawTeam.write, `teams.${teamId}.write`),
+      promote: parseStringList(rawTeam.promote, `teams.${teamId}.promote`)
+    };
+  }
+  return teams;
+}
+function validateScopeProfileTeamReferences(profiles, teams) {
+  for (const [profileId, profile] of Object.entries(profiles)) {
+    const teamId = profile.teamProject?.teamId;
+    if (teamId && !Object.prototype.hasOwnProperty.call(teams, teamId)) {
+      throw new Error(
+        `scopeProfiles.${profileId}.teamProject.teamId references unknown team: ${teamId}`
+      );
+    }
+  }
+}
 function parseBoundedIntegerMs(value, fallback, min, max) {
   const coerced = coerceNumber(value);
   if (coerced === void 0) return fallback;
@@ -608,6 +830,42 @@ function resolveNamespaceCatalogEnabled(configValue) {
   }
   return true;
 }
+function readNestedConfig(cfg, blockName, key) {
+  const block = validateNestedConfigBlock(cfg, blockName);
+  if (!block) return void 0;
+  return block[key];
+}
+function validateNestedConfigBlock(cfg, blockName) {
+  const block = cfg[blockName];
+  if (block === void 0 || block === null) return void 0;
+  if (typeof block !== "object" || Array.isArray(block)) {
+    throw new Error(`${blockName} must be a plain object`);
+  }
+  return block;
+}
+function readFlatOrNestedConfig(cfg, flatKey, blockName, nestedKey) {
+  return cfg[flatKey] !== void 0 ? cfg[flatKey] : readNestedConfig(cfg, blockName, nestedKey);
+}
+function resolveBooleanConfig(value, defaultValue, keyName) {
+  if (value === void 0 || value === null) return defaultValue;
+  const coerced = coerceBool(value);
+  if (coerced === void 0) {
+    throw new Error(
+      `${keyName} must be a boolean-like value (true/false/1/0/yes/no/on/off); got ${JSON.stringify(value)}`
+    );
+  }
+  return coerced;
+}
+function resolvePositiveIntegerConfig(value, defaultValue, keyName) {
+  if (value === void 0 || value === null) return defaultValue;
+  const coerced = coerceNumber(value);
+  if (coerced === void 0 || !Number.isFinite(coerced) || !Number.isInteger(coerced) || coerced < 1) {
+    throw new Error(
+      `${keyName} must be a positive integer; got ${JSON.stringify(value)}`
+    );
+  }
+  return coerced;
+}
 function isOpenaiApiKeyDisabled(value) {
   return value === false || typeof value === "string" && value.trim().toLowerCase() === "false";
 }
@@ -888,6 +1146,7 @@ function parseConfig(raw) {
   } else {
     cfg = baseCfg;
   }
+  validateNestedConfigBlock(cfg, "maintenance");
   const modelSource = cfg.modelSource === "gateway" ? "gateway" : "plugin";
   const openaiApiKeyDisabled = isOpenaiApiKeyDisabled(cfg.openaiApiKey);
   let apiKey;
@@ -1051,6 +1310,21 @@ function parseConfig(raw) {
     globalFallback: codingGlobalFallbackRaw === void 0 ? true : codingGlobalFallbackRaw
   };
   const memoryDir = typeof cfg.memoryDir === "string" && cfg.memoryDir.length > 0 ? expandTildePath(cfg.memoryDir) : DEFAULT_MEMORY_DIR;
+  const scopeProfiles = parseScopeProfiles(cfg.scopeProfiles);
+  const teams = parseScopeTeams(cfg.teams);
+  validateScopeProfileTeamReferences(scopeProfiles, teams);
+  const defaultScopeProfile = (() => {
+    if (cfg.defaultScopeProfile === void 0 || cfg.defaultScopeProfile === null) {
+      return void 0;
+    }
+    if (typeof cfg.defaultScopeProfile !== "string" || cfg.defaultScopeProfile.trim().length === 0) {
+      throw new Error("defaultScopeProfile must be a non-empty string");
+    }
+    return cfg.defaultScopeProfile.trim();
+  })();
+  if (defaultScopeProfile !== void 0 && scopeProfiles[defaultScopeProfile] === void 0) {
+    throw new Error(`defaultScopeProfile references unknown scope profile: ${defaultScopeProfile}`);
+  }
   const rawIdentityInjectionMode = cfg.identityInjectionMode;
   const identityInjectionMode = rawIdentityInjectionMode && VALID_IDENTITY_INJECTION_MODES.includes(rawIdentityInjectionMode) ? rawIdentityInjectionMode : "recovery_only";
   const identityContinuityEnabled = cfg.identityContinuityEnabled === true;
@@ -1150,6 +1424,66 @@ function parseConfig(raw) {
   const sharedCrossSignalSemanticEnabled = cfg.sharedCrossSignalSemanticEnabled === true || cfg.crossSignalsSemanticEnabled === true;
   const sharedCrossSignalSemanticTimeoutMs = typeof cfg.sharedCrossSignalSemanticTimeoutMs === "number" ? Math.max(1, Math.floor(cfg.sharedCrossSignalSemanticTimeoutMs)) : typeof cfg.crossSignalsSemanticTimeoutMs === "number" ? Math.max(1, Math.floor(cfg.crossSignalsSemanticTimeoutMs)) : 4e3;
   const recallPipelineConfig = buildRecallPipelineConfig(cfg);
+  const maintenanceNamespaceFanoutEnabled = resolveBooleanConfig(
+    readFlatOrNestedConfig(
+      cfg,
+      "maintenanceNamespaceFanoutEnabled",
+      "maintenance",
+      "namespaceFanoutEnabled"
+    ),
+    true,
+    "maintenance.namespaceFanoutEnabled"
+  );
+  const maintenanceMaxNamespacesPerCycle = resolvePositiveIntegerConfig(
+    readFlatOrNestedConfig(
+      cfg,
+      "maintenanceMaxNamespacesPerCycle",
+      "maintenance",
+      "maxNamespacesPerCycle"
+    ),
+    20,
+    "maintenance.maxNamespacesPerCycle"
+  );
+  const maintenanceIncludeProjectNamespaces = resolveBooleanConfig(
+    readFlatOrNestedConfig(
+      cfg,
+      "maintenanceIncludeProjectNamespaces",
+      "maintenance",
+      "includeProjectNamespaces"
+    ),
+    true,
+    "maintenance.includeProjectNamespaces"
+  );
+  const maintenanceIncludeBranchNamespaces = resolveBooleanConfig(
+    readFlatOrNestedConfig(
+      cfg,
+      "maintenanceIncludeBranchNamespaces",
+      "maintenance",
+      "includeBranchNamespaces"
+    ),
+    false,
+    "maintenance.includeBranchNamespaces"
+  );
+  const maintenanceIncludeTeamProjectNamespaces = resolveBooleanConfig(
+    readFlatOrNestedConfig(
+      cfg,
+      "maintenanceIncludeTeamProjectNamespaces",
+      "maintenance",
+      "includeTeamProjectNamespaces"
+    ),
+    true,
+    "maintenance.includeTeamProjectNamespaces"
+  );
+  const maintenanceNamespaceLockStaleMs = resolvePositiveIntegerConfig(
+    readFlatOrNestedConfig(
+      cfg,
+      "maintenanceNamespaceLockStaleMs",
+      "maintenance",
+      "namespaceLockStaleMs"
+    ),
+    10 * 6e4,
+    "maintenance.namespaceLockStaleMs"
+  );
   return {
     openaiApiKey: apiKey,
     openaiBaseUrl: baseUrl,
@@ -1853,6 +2187,12 @@ function parseConfig(raw) {
     // QMD maintenance (debounced singleflight)
     qmdMaintenanceEnabled: cfg.qmdMaintenanceEnabled !== false,
     qmdMaintenanceDebounceMs: typeof cfg.qmdMaintenanceDebounceMs === "number" ? cfg.qmdMaintenanceDebounceMs : 3e4,
+    maintenanceNamespaceFanoutEnabled,
+    maintenanceMaxNamespacesPerCycle,
+    maintenanceIncludeProjectNamespaces,
+    maintenanceIncludeBranchNamespaces,
+    maintenanceIncludeTeamProjectNamespaces,
+    maintenanceNamespaceLockStaleMs,
     qmdAutoEmbedEnabled: cfg.qmdAutoEmbedEnabled === true,
     qmdEmbedMinIntervalMs: typeof cfg.qmdEmbedMinIntervalMs === "number" ? cfg.qmdEmbedMinIntervalMs : 60 * 6e4,
     qmdUpdateTimeoutMs: typeof cfg.qmdUpdateTimeoutMs === "number" ? cfg.qmdUpdateTimeoutMs : 9e4,
@@ -1916,6 +2256,9 @@ function parseConfig(raw) {
       includeInRecallByDefault: p?.includeInRecallByDefault === true
     })).filter((p) => p.name.length > 0) : [],
     defaultRecallNamespaces: Array.isArray(cfg.defaultRecallNamespaces) ? ["self", "shared"].filter((x) => cfg.defaultRecallNamespaces.includes(x)) : ["self", "shared"],
+    scopeProfiles,
+    defaultScopeProfile,
+    teams,
     cronRecallMode: cfg.cronRecallMode === "none" ? "none" : cfg.cronRecallMode === "allowlist" ? "allowlist" : "all",
     cronRecallAllowlist: Array.isArray(cfg.cronRecallAllowlist) ? cfg.cronRecallAllowlist.filter((v) => typeof v === "string" && v.length > 0) : [],
     cronRecallPolicyEnabled: cfg.cronRecallPolicyEnabled !== false,
@@ -2826,4 +3169,4 @@ export {
   VALID_MEMORY_CATEGORIES,
   parseConfig
 };
-//# sourceMappingURL=chunk-YLZLPVKK.js.map
+//# sourceMappingURL=chunk-CTAV55JM.js.map