@litfamily/lithermes 1.0.4 → 1.0.5

package/src/lib/modelConfig.js

@@ -6,6 +6,7 @@ const { OPENAI_PROVIDER, RESPONSES_MODE, classifyHostVersion,
 const {
   ASTRA_MODEL,
   MANAGED_PROVIDER_MODELS,
+  MODEL_IDS,
   applyManagedRoute,
   customChildTransportReason,
   inspectEffectiveRouteSafety,
@@ -17,8 +18,6 @@ const {
   unavailableTuiRouteVisibility,
 } = require("./modelRoutePolicy");
 
-const MODELS = new Set(["gpt-6-astra", "gpt-5.6-sol", "gpt-5.6-terra", "gpt-5.6-luna"]);
-
 // The route every "configured" verdict is measured against: explicit installer
 // options win; otherwise the document's own route when it is a catalog route;
 // otherwise today's shipped default.
@@ -45,6 +44,12 @@ function expectedRoute(options = {}, document = null) {
 const SAFE_CONTEXT_LENGTH = 372000;
 const SAFE_COMPRESSION_THRESHOLD = 0.9;
 const SAFE_AUTO_COMPACTION_LIMIT = SAFE_CONTEXT_LENGTH * SAFE_COMPRESSION_THRESHOLD;
+const LEGACY_CONTEXT_MODELS = new Set([
+  "gpt-5.6",
+  "gpt-5.6-sol",
+  "gpt-5.6-terra",
+  "gpt-5.6-luna",
+]);
 const MANAGED_SAMPLING_KEYS = ["temperature", "top_p", "top_logprobs"];
 
 function hasValue(document, path) {
@@ -156,7 +161,7 @@ function classificationFromDocument(document, fresh) {
   if (provider === OPENAI_PROVIDER && (dispatch === "gpt-5.4" || dispatch === "gpt-5.5")) {
     return { class: "managed_legacy", originalDispatchId };
   }
-  if (provider === OPENAI_PROVIDER && MODELS.has(dispatch)) {
+  if (provider === OPENAI_PROVIDER && MODEL_IDS.has(dispatch)) {
     return { class: "existing_managed", originalDispatchId };
   }
   if (MANAGED_PROVIDER_MODELS[provider]?.has(dispatch)) {
@@ -364,10 +369,9 @@ function planModelConfig(text, options = {}) {
   }
   const document = boundary.document;
   applyManagedRoute(document, route);
-  // The verified legacy context/compression defaults belong to legacy model
-  // resets only. Astra has no host-published limit evidence, so an Astra reset
-  // preserves explicit values and leaves missing values absent.
-  if (options.reconfigure && route.model !== ASTRA_MODEL && route.childModel !== ASTRA_MODEL) {
+  // The verified context/compression defaults apply only to explicit GPT-5.6
+  // model resets. GPT-6 model routes have no published evidence for these limits.
+  if (options.reconfigure && LEGACY_CONTEXT_MODELS.has(route.model)) {
     document.setIn(["model", "context_length"], SAFE_CONTEXT_LENGTH);
     document.setIn(["compression", "threshold"], SAFE_COMPRESSION_THRESHOLD);
   }

package/src/lib/modelRoutePolicy.js

@@ -1,38 +1,77 @@
 const ASTRA_MODEL = "gpt-6-astra";
-const ASTRA_EFFORTS = new Set(["low", "medium", "high", "xhigh", "max"]);
+const GPT6_LEAD_EFFORTS = new Set(["low", "medium", "high", "xhigh", "max", "ultra"]);
+const ASTRA_EFFORTS = GPT6_LEAD_EFFORTS;
 const PARENT_MODEL = ASTRA_MODEL;
 const PARENT_EFFORT = "xhigh";
-const CHILD_MODEL = "gpt-5.6-luna";
+const SOL_MODEL = "gpt-6-sol";
+const CHILD_MODEL = "gpt-6-luna";
+const LEGACY_SOL_MODEL = "gpt-5.6-sol";
+const LEGACY_CHILD_MODEL = "gpt-5.6-luna";
 const CHILD_EFFORT = "max";
-const LUNA_EFFORTS = new Set(["high", "max"]);
+const GPT6_LUNA_EFFORTS = new Set(["low", "medium", "high", "xhigh", "max"]);
+const LEGACY_LUNA_EFFORTS = new Set(["high", "max"]);
+const LUNA_EFFORTS = LEGACY_LUNA_EFFORTS;
+const LUNA_MODELS = new Set([CHILD_MODEL, LEGACY_CHILD_MODEL]);
 const TERRA_MODEL = "gpt-5.6-terra";
 const TERRA_EFFORTS = new Set(["high", "xhigh", "max"]);
+const LEGACY_SOL_EFFORTS = new Set(["high", "xhigh"]);
+const MODEL_EFFORTS = new Map([
+  [ASTRA_MODEL, GPT6_LEAD_EFFORTS],
+  [SOL_MODEL, GPT6_LEAD_EFFORTS],
+  [CHILD_MODEL, GPT6_LUNA_EFFORTS],
+  [LEGACY_SOL_MODEL, LEGACY_SOL_EFFORTS],
+  [LEGACY_CHILD_MODEL, LEGACY_LUNA_EFFORTS],
+  ["gpt-5.6", new Set(["high"])],
+  [TERRA_MODEL, TERRA_EFFORTS],
+]);
 const CHILD_TRANSPORT_KEYS = ["provider", "base_url", "api_mode"];
 const { OPENAI_PROVIDER: OPENAI_PROVIDER_ID } = require("./modelConfigBoundary");
 const XAI_PROVIDER_ID = "xai";
 // Installer choice catalog (plans/references/installer-choice-contract.md, LitHermes row).
-// OpenAI rows: Astra exposes exactly the five Responses efforts; the existing Sol,
-// Luna, and general GPT-5.6 rows remain below it and Luna+xhigh is never listed. xAI rows: the
-// reasoning-capable models of the Hermes 0.19 static xAI catalog
+// OpenAI rows follow each model's listed effort set, including selectable legacy
+// GPT-5.6 routes. xAI rows use the reasoning-capable models of the Hermes 0.19 catalog
 // (hermes_cli/models.py `_XAI_STATIC_FALLBACK`), newest first, with the Hermes
 // reasoning_effort vocabulary (hermes_cli/config.py delegation.reasoning_effort).
 const ROUTE_CATALOG = {
   [OPENAI_PROVIDER_ID]: {
     credentialEnv: null,
-    label: "OpenAI OAuth Responses (Astra + GPT-5.6)",
+    label: "OpenAI OAuth Responses (Astra + Sol + Luna)",
     rows: [
-      ...["low", "medium", "high", "xhigh", "max"].map((effort) => ({
+      ...["low", "medium", "high", "xhigh", "max", "ultra"].map((effort) => ({
         effort,
         model: ASTRA_MODEL,
-        note: effort === "max"
+        note: effort === "ultra"
           ? "deepest Astra reasoning"
           : effort === PARENT_EFFORT
             ? "recommended lead"
             : "Astra Responses effort",
       })),
-      { effort: PARENT_EFFORT, model: "gpt-5.6-sol", note: "existing Sol lead route" },
-      { effort: CHILD_EFFORT, model: CHILD_MODEL, note: "balanced (recommended helper)" },
-      { effort: "high", model: CHILD_MODEL, note: "balanced, lighter effort" },
+      ...["low", "medium", "high", "xhigh", "max", "ultra"].map((effort) => ({
+        effort,
+        model: SOL_MODEL,
+        note: effort === PARENT_EFFORT ? "coding lead alternative" : "Sol Responses effort",
+      })),
+      ...["low", "medium", "high", "xhigh", "max"].map((effort) => ({
+        effort,
+        model: CHILD_MODEL,
+        note: effort === CHILD_EFFORT
+          ? "balanced (recommended helper)"
+          : effort === "high"
+            ? "balanced, lighter effort"
+            : "Luna Responses effort",
+      })),
+      ...["high", "xhigh"].map((effort) => ({
+        effort,
+        model: LEGACY_SOL_MODEL,
+        note: "previous-generation Sol lead route",
+      })),
+      ...["high", "xhigh", "max"].map((effort) => ({
+        effort,
+        model: TERRA_MODEL,
+        note: "previous-generation Terra route",
+      })),
+      { effort: CHILD_EFFORT, model: LEGACY_CHILD_MODEL, note: "previous-generation balanced helper" },
+      { effort: "high", model: LEGACY_CHILD_MODEL, note: "previous-generation lighter helper" },
       { effort: "high", model: "gpt-5.6", note: "general model" },
     ],
     lead: { effort: PARENT_EFFORT, model: PARENT_MODEL },
@@ -55,6 +94,10 @@ const PROVIDER_IDS = Object.keys(ROUTE_CATALOG);
 const MANAGED_PROVIDER_MODELS = Object.fromEntries(
   PROVIDER_IDS.map((id) => [id, new Set(ROUTE_CATALOG[id].rows.map((row) => row.model))]),
 );
+const MODEL_IDS = new Set([
+  ...MANAGED_PROVIDER_MODELS[OPENAI_PROVIDER_ID],
+  TERRA_MODEL,
+]);
 const MANAGED_PROVIDERS = new Set(PROVIDER_IDS);
 const UNSAFE_ROUTE_CODE = "LITHERMES_UNSAFE_MODEL_ROUTE";
 const REVIEWER_ROUTE_NAME = String.fromCharCode(109, 111, 109, 117, 115);
@@ -83,42 +126,32 @@ function inspectEffectiveRouteSafety(document, expectedProvider) {
   const managedRoutes = routes.filter((route) => route.provider === expectedProvider);
   for (const route of managedRoutes) {
     if (transportReason && route.route === "global_child") continue;
-    if (route.model === ASTRA_MODEL && !ASTRA_EFFORTS.has(route.effort)) {
-      return {
-        classificationClass: "astra_effort_unsupported",
-        code: UNSAFE_ROUTE_CODE,
-        observedSource: `${route.route} model, effort, and provider config`,
-        reason: `${route.route} Astra effort is unsupported or missing; choose one of: ${[...ASTRA_EFFORTS].join(", ")}`,
-        route: route.route,
-        status: "blocked",
-      };
-    }
-    if (route.model === CHILD_MODEL && route.effort === "xhigh") {
-      return {
-        classificationClass: "conflicting_luna_xhigh",
-        code: UNSAFE_ROUTE_CODE,
-        observedSource: `${route.route} model, effort, and provider config`,
-        reason: `${route.route} Luna xhigh is a forbidden pair (Luna runs at high or max)`,
-        route: route.route,
-        status: "blocked",
-      };
-    }
-    if (route.model === CHILD_MODEL && !LUNA_EFFORTS.has(route.effort)) {
-      return {
-        classificationClass: "luna_effort_below_high",
-        code: UNSAFE_ROUTE_CODE,
-        observedSource: `${route.route} model, effort, and provider config`,
-        reason: `${route.route} Luna effort is below high or missing`,
-        route: route.route,
-        status: "blocked",
-      };
-    }
-    if (route.model === TERRA_MODEL && !TERRA_EFFORTS.has(route.effort)) {
+    const modelEfforts = MODEL_EFFORTS.get(route.model);
+    if (modelEfforts && !modelEfforts.has(route.effort)) {
+      const isAstra = route.model === ASTRA_MODEL;
+      const isLuna = LUNA_MODELS.has(route.model);
+      const isLegacyLunaXhigh = route.model === LEGACY_CHILD_MODEL && route.effort === "xhigh";
       return {
-        classificationClass: "terra_effort_below_high",
+        classificationClass: isAstra
+          ? "astra_effort_unsupported"
+          : isLegacyLunaXhigh
+            ? "conflicting_luna_xhigh"
+            : isLuna
+              ? "luna_effort_below_high"
+              : route.model === TERRA_MODEL
+                ? "terra_effort_below_high"
+                : "model_effort_unsupported",
         code: UNSAFE_ROUTE_CODE,
         observedSource: `${route.route} model, effort, and provider config`,
-        reason: `${route.route} TERRA effort is below high or missing`,
+        reason: isAstra
+          ? `${route.route} Astra effort is unsupported or missing; choose one of: ${[...modelEfforts].join(", ")}`
+          : isLegacyLunaXhigh
+            ? `${route.route} Luna xhigh is a forbidden pair (legacy Luna runs at high or max)`
+            : isLuna
+              ? `${route.route} Luna effort is unsupported; choose one of: ${[...modelEfforts].join(", ")}`
+              : route.model === TERRA_MODEL
+                ? `${route.route} TERRA effort is below high or missing`
+                : `${route.route} ${route.model} effort is unsupported or missing; choose one of: ${[...modelEfforts].join(", ")}`,
         route: route.route,
         status: "blocked",
       };
@@ -140,7 +173,7 @@ function inspectEffectiveRouteSafety(document, expectedProvider) {
   }
   return {
     observedSource: "parent and global delegation model policy",
-    reason: "no effective under-effort Luna or TERRA route is configured",
+    reason: "no effective model and effort pair outside the model catalog is configured",
     status: "safe",
   };
 }
@@ -162,8 +195,8 @@ function resolveRow(provider, role, model, effort) {
   const hasModel = model !== undefined;
   const hasEffort = effort !== undefined;
   const resolvedModel = hasModel ? String(model) : preset.model;
-  if (resolvedModel === CHILD_MODEL && hasEffort && effort === "xhigh") {
-    throw new Error(`${role} route ${CHILD_MODEL} xhigh is a forbidden pair; Luna runs at high or max`);
+  if (resolvedModel === LEGACY_CHILD_MODEL && hasEffort && effort === "xhigh") {
+    throw new Error(`${role} route ${resolvedModel} xhigh is a forbidden pair; legacy Luna runs at high or max`);
   }
   const rowsForModel = catalog.rows.filter((row) => row.model === resolvedModel);
   if (!rowsForModel.length) {
@@ -244,10 +277,10 @@ function inspectManagedRoute(document, expectedProvider, route = managedRequest(
     && childModel === route.childModel
     && childEffort === route.childEffort;
   const legacyConfigured = parentProvider === expectedProvider
-    && parentModel === "gpt-5.6-luna"
+    && parentModel === LEGACY_CHILD_MODEL
     && parentEffort === "max"
-    && childModel === CHILD_MODEL
-    && LUNA_EFFORTS.has(childEffort);
+    && childModel === LEGACY_CHILD_MODEL
+    && LEGACY_LUNA_EFFORTS.has(childEffort);
   if (!configured && !legacyConfigured) {
     return {
       status: "unavailable",
@@ -359,8 +392,18 @@ function formatManagedRoute(route) {
 module.exports = {
   ASTRA_EFFORTS,
   ASTRA_MODEL,
+  CHILD_MODEL,
+  GPT6_LEAD_EFFORTS,
+  GPT6_LUNA_EFFORTS,
+  LEGACY_LUNA_EFFORTS,
+  LEGACY_CHILD_MODEL,
+  LEGACY_SOL_MODEL,
+  LUNA_EFFORTS,
+  LUNA_MODELS,
   MANAGED_PROVIDER_MODELS,
+  MODEL_IDS,
   OPENAI_PROVIDER_ID,
+  SOL_MODEL,
   PROVIDER_IDS,
   ROUTE_CATALOG,
   XAI_PROVIDER_ID,

package/src/lib/skillPayload.js

@@ -16,7 +16,7 @@ const MAX_PAYLOAD_TOTAL_BYTES = 16 * 1024 * 1024;
 const requiredSkills = [
   "lit-burnoff-file", "autoconference", "autoresearch", "browser-drive", "comment-checker", "debugging",
   "deep-interview",
-  "frontend-ui-ux", "lit-commit", "lit-crucible", "lit-init",
+  "frontend-ui-ux", "readme-studio", "lit-commit", "lit-crucible", "lit-init",
   "lit-korean", "lit-comprehend", "lit-handoff", "lit-plan", "lit-recap",
   "lit-scientific-visualization", "litgoal", "litresearch", "litwork", "lsp",
   "lsp-setup", "lit-code", "refactor", "lit-burnoff", "review-work",