@litfamily/lithermes 1.0.19 → 1.0.21

package/assets/lithermes-plugin/workflow_map.py

@@ -0,0 +1,206 @@
+"""One plain-text workflow map row for LIT replies, read from durable state.
+
+The reply transform is the plugin's only user-visible channel, and Hermes
+cannot colour it, so the row carries stage emoji and a block bar instead:
+
+    🔥 LIT · lit-loop — 📝 plan ✓ › 🔨 WORK ▰▰▰▱▱▱▱ 3/7 › 🔍 · › 🏁 ·
+
+The newest durable record in the workspace anchors the row: a plan file under
+plans/, a run state, a bounded-work state, or the litgoal goal (the session's
+own store first, then the legacy one). A stage with no durable signal is left
+out, and no signal at all draws no row. The row never carries a command, a
+path, a plan name, or any argument. Reads are bounded and never write.
+"""
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+try:
+    from .core_plans import FINAL_VERIFIER_ROW, IMPLEMENTATION_ROW, _outside_fence_lines
+    from .litgoal import store as _litgoal_store
+except (ImportError, ModuleNotFoundError):
+    from core_plans import FINAL_VERIFIER_ROW, IMPLEMENTATION_ROW, _outside_fence_lines
+    from litgoal import store as _litgoal_store
+
+MAX_PLAN_BYTES = 1_000_000
+MAX_STATE_BYTES = 2_000_000
+BAR_CELLS = 7
+EMOJI = {"plan": "📝", "work": "🔨", "review": "🔍", "done": "🏁"}
+# Only the plan → work → review chain draws the map; a prose, office, motion or
+# research reply would show an unrelated workflow.
+WORKFLOW_ROUTES = frozenset({
+    "litwork", "lit-loop", "lit-plan", "start-work", "litgoal", "review-work",
+    "deep-interview", "lit-team", "lit-recap",
+})
+
+
+def _mtime(path: Path) -> float:
+    try:
+        return path.stat().st_mtime
+    except OSError:
+        return -1.0
+
+
+def _newest(paths) -> Path | None:
+    return max(paths, key=_mtime, default=None)
+
+
+def _json(path: Path | None) -> dict | None:
+    try:
+        if path is None or not path.is_file() or path.stat().st_size > MAX_STATE_BYTES:
+            return None
+        data = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, ValueError):
+        return None
+    return data if isinstance(data, dict) else None
+
+
+def _resolved(raw: object) -> str:
+    try:
+        return str(Path(str(raw)).expanduser().resolve()) if raw else ""
+    except (OSError, ValueError):
+        return ""
+
+
+def _plan_counts(raw: object) -> tuple[int, int, int, int] | None:
+    """(tasks done, tasks, checks done, checks) from a plan's column-zero rows."""
+    try:
+        path = Path(str(raw or "")).expanduser()
+        if not raw or path.suffix.lower() != ".md" or not path.is_file() or path.stat().st_size > MAX_PLAN_BYTES:
+            return None
+        text = path.read_text(encoding="utf-8")
+    except (OSError, ValueError):
+        return None
+    counts = [0, 0, 0, 0]
+    for _, line in _outside_fence_lines(text):
+        offset = 0 if IMPLEMENTATION_ROW.match(line) else 2 if FINAL_VERIFIER_ROW.match(line) else None
+        if offset is not None:
+            counts[offset + 1] += 1
+            counts[offset] += line[3] in "xX"
+    return tuple(counts)
+
+
+def _goal(workspace: Path, session_id: str):
+    """(goals.json path, active goal) from the session's store, else the legacy one."""
+    try:
+        scopes = [session_id] if _litgoal_store.normalize_session_id(session_id) else []
+    except ValueError:
+        scopes = []
+    for scope in [*scopes, ""]:
+        path = _litgoal_store.goals_path(workspace, scope)
+        if not path.is_file():
+            continue
+        try:
+            goal = _litgoal_store.load_or_create(workspace, scope).active_goal()
+        except (OSError, ValueError):
+            return None
+        return (path, goal) if goal is not None else None
+    return None
+
+
+def _bar(done: int, total: int) -> str:
+    filled = min(BAR_CELLS, done * BAR_CELLS // total)
+    return "▰" * filled + "▱" * (BAR_CELLS - filled)
+
+
+def _stage(name: str, state: str, done: int = 0, total: int = 0) -> str:
+    emoji = EMOJI[name]
+    if state == "done":
+        return f"{emoji} {name} ✓"
+    if state == "pending":
+        return f"{emoji} ·"
+    counter = f" {_bar(done, total)} {done}/{total}" if total else ""
+    return f"{emoji} {name.upper()}{counter}"
+
+
+def _progress_stages(plan: tuple | None, work: tuple[int, int] | None, finished: bool) -> list[str]:
+    """Stages after a plan exists: work from `work` or plan tasks, review from plan checks."""
+    tasks = work if work is not None else (plan[:2] if plan else None)
+    checks = plan[2:] if plan else None
+    stages: list[str] = []
+    work_done = finished
+    if tasks and tasks[1]:
+        work_done = finished or tasks[0] >= tasks[1]
+        stages.append(_stage("work", "done" if work_done else "current", *tasks))
+    review_done = work_done
+    if checks and checks[1]:
+        review_done = finished or (work_done and checks[0] >= checks[1])
+        state = "done" if review_done else "current" if work_done else "pending"
+        stages.append(_stage("review", state, *checks))
+    stages.append(_stage("done", "done" if finished or (work_done and review_done) else "pending"))
+    return stages
+
+
+def _goal_stages(goal) -> list[str]:
+    total = len(goal.criteria)
+    passed = sum(1 for criterion in goal.criteria if criterion.status == "pass")
+    complete = goal.status == "complete"
+    blocked = goal.status == "review_blocked" or any(not b.resolved for b in goal.review_blockers)
+    stages = []
+    work_done = complete or (total > 0 and passed >= total)
+    if total:
+        stages.append(_stage("work", "done" if work_done else "current", passed, total))
+    review = "done" if complete else "current" if blocked or work_done else "pending"
+    stages.append(_stage("review", review))
+    stages.append(_stage("done", "done" if complete else "pending"))
+    return stages
+
+
+def workflow_stages(workspace: Path, session_id: str = "") -> list[str] | None:
+    hermes = Path(workspace) / ".hermes" / "lithermes"
+    run_file = _newest((hermes / "runs").glob("*/state.json"))
+    work_file = _newest((hermes / "work").glob("*/state.json"))
+    # Checking off rows rewrites the plan a run executes; only a plan no run or
+    # work state points at can mean the user is planning again.
+    executing = {_resolved((_json(path) or {}).get("plan")) for path in (run_file, work_file) if path}
+    plan_file = _newest(path for path in (Path(workspace) / "plans").glob("*.md")
+                        if path.is_file() and _resolved(path) not in executing)
+    goal = _goal(Path(workspace), str(session_id or ""))
+    candidates = [(path, kind) for path, kind in ((plan_file, "plan"), (run_file, "run"), (work_file, "work")) if path]
+    if goal:
+        candidates.append((goal[0], "goal"))
+    if not candidates:
+        return None
+    anchor, kind = max(candidates, key=lambda item: _mtime(item[0]))
+
+    if kind == "plan":
+        counts = _plan_counts(anchor)
+        stages = [_stage("plan", "current")]
+        if counts and counts[1]:
+            stages.append(_stage("work", "pending"))
+        if counts and counts[3]:
+            stages.append(_stage("review", "pending"))
+        return stages + [_stage("done", "pending")]
+    if kind == "goal":
+        run = _json(run_file) or {}
+        has_plan = _plan_counts(run.get("plan")) is not None
+        return ([_stage("plan", "done")] if has_plan else []) + _goal_stages(goal[1])
+    state = _json(anchor)
+    if state is None:
+        return None
+    counts = _plan_counts(state.get("plan"))
+    if kind == "run":
+        if counts is None or not (counts[1] or counts[3]):
+            return None
+        return [_stage("plan", "done"), *_progress_stages(counts, None, False)]
+    status = state.get("status")
+    items = state.get("progress") if isinstance(state.get("progress"), list) else []
+    if status not in ("active", "paused", "completed"):
+        return None
+    work = (sum(1 for item in items if isinstance(item, dict) and item.get("status") == "pass"), len(items)) if items else None
+    plan_tasks = (counts[0], counts[1], 0, 0) if counts else None
+    return [_stage("plan", "done"), *_progress_stages(plan_tasks, work, status == "completed")]
+
+
+def workflow_row(route: str, workspace: Path, session_id: str = "") -> str | None:
+    """The map row for this LIT reply, or None when no stage has a durable signal."""
+    if route not in WORKFLOW_ROUTES:
+        return None
+    try:
+        stages = workflow_stages(workspace, session_id)
+    except (OSError, ValueError):
+        return None
+    if not stages:
+        return None
+    return f"🔥 LIT · {route} — " + " › ".join(stages)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@litfamily/lithermes",
-  "version": "1.0.19",
+  "version": "1.0.21",
   "description": "Hermes Agent plugin that plans, builds, checks and hands off your work when you add one word, lit, to a request.",
   "keywords": [
     "hermes-agent",

package/readme-assets/badge-version.svg

@@ -1 +1 @@
-<svg xmlns="http://www.w3.org/2000/svg" width="146" height="20" role="img" aria-label="release: 1.0.19"><title>release: 1.0.19</title><g shape-rendering="crispEdges"><rect width="49" height="20" fill="#080d14"/><rect x="49" width="97" height="20" fill="#ff6337"/></g><g fill="#fff" text-anchor="middle" font-family="Verdana,Geneva,DejaVu Sans,sans-serif" text-rendering="geometricPrecision" font-size="110"><text x="255" y="140" textLength="390" transform="scale(.1)">release</text><text x="965" y="140" textLength="870" transform="scale(.1)" fill="#080D14">1.0.19</text></g></svg>
+<svg xmlns="http://www.w3.org/2000/svg" width="146" height="20" role="img" aria-label="release: 1.0.21"><title>release: 1.0.21</title><g shape-rendering="crispEdges"><rect width="49" height="20" fill="#080d14"/><rect x="49" width="97" height="20" fill="#ff6337"/></g><g fill="#fff" text-anchor="middle" font-family="Verdana,Geneva,DejaVu Sans,sans-serif" text-rendering="geometricPrecision" font-size="110"><text x="255" y="140" textLength="390" transform="scale(.1)">release</text><text x="965" y="140" textLength="870" transform="scale(.1)" fill="#080D14">1.0.21</text></g></svg>

package/src/cli.js

@@ -9,6 +9,8 @@ const { listHud, applyHud, clearHud, previewClearHud, previewHud, promptAccent,
 const { supportsColor, findAccent, skinName } = require("./lib/skins");
 const {
   readConfig,
+  readBellOnCompleteConfig,
+  setBellOnCompleteConfig,
   clearDisplaySkinConfig,
   readDisplaySkinConfig,
   readOutputStyleConfig,
@@ -37,7 +39,7 @@ const COMMAND_SPECS = {
     flags: {
       yes: "", "dry-run": "", offline: "", json: "", force: "", "reconfigure-model": "",
       provider: "ID", model: "ID", effort: "LEVEL", "child-provider": "ID", "child-model": "ID", "child-effort": "LEVEL",
-      spinner: "", "no-spinner": "", hud: "<accent>", "no-hud": "", style: "ID", "no-style": "",
+      spinner: "", "no-spinner": "", hud: "<accent>", "no-hud": "", style: "ID", "no-style": "", bell: "", "no-bell": "",
       "patch-installed-hermes": "", "no-patch-installed-hermes": "", "no-auto-update": "", ...HOME, "hermes-repo": "PATH",
     },
   },
@@ -405,6 +407,57 @@ async function maybePickHudAccent(flags, runtime = {}, { promptForAccent = false
   if (entry) console.log(applyHud(entry.accent, flags));
 }
 
+// Hermes rings the terminal bell (plus a desktop notice) at the end of a turn
+// when display.bell_on_complete is true; its default is off. The installer sets
+// it only on --bell or a "y" to the interactive question, never changes a value
+// the user already chose, and leaves config.yaml alone when the edit is not
+// clean or the file changed while the question was open.
+async function maybeOfferBell(flags, runtime = {}, { prompt = false } = {}) {
+  if (flags["dry-run"] || flags["no-bell"]) return;
+  const say = flags.json ? console.error : console.log;
+  const home = resolveHome(flags);
+  const before = readConfig(home);
+  const current = readBellOnCompleteConfig(before);
+  const byHand = "set display.bell_on_complete: true by hand in config.yaml to hear a bell when a turn finishes.";
+  if (current === undefined) {
+    if (flags.bell) console.error(`Finish bell: config.yaml does not parse; left unchanged. ${byHand}`);
+    return;
+  }
+  if (current !== null) {
+    if (flags.bell) say(`Finish bell: kept your display.bell_on_complete: ${current}.`);
+    return;
+  }
+  let wanted = Boolean(flags.bell);
+  if (!wanted && prompt) {
+    const env = runtime.env || process.env;
+    const streams = runtime.streams || { stdin: process.stdin, stdout: process.stdout };
+    const input = streams.stdin || process.stdin;
+    const output = streams.stdout || process.stdout;
+    const interactive = runtime.isInteractive ?? Boolean(input.isTTY && output.isTTY);
+    if (!interactive || "CI" in env) return;
+    wanted = await new Promise((resolve) => {
+      const rl = readline.createInterface({ input, output, terminal: false });
+      rl.on("close", () => resolve(false));
+      rl.question("Ring the terminal bell when a Hermes turn finishes? [y/N] ", (answer) => {
+        resolve(/^\s*y(es)?\s*$/i.test(answer));
+        rl.close();
+      });
+    });
+  }
+  if (!wanted) return;
+  const after = setBellOnCompleteConfig(before);
+  if (after === null) {
+    console.error(`Finish bell: config.yaml has a shape the installer will not edit; left unchanged. ${byHand}`);
+    return;
+  }
+  if (readConfig(home) !== before) {
+    console.error(`Finish bell: config.yaml changed while asking; left unchanged. ${byHand}`);
+    return;
+  }
+  writeConfig(home, after);
+  say("Finish bell on: Hermes rings the terminal when a turn finishes (display.bell_on_complete).");
+}
+
 async function main(argv, runtime = {}) {
   const parsed = parseArgs(argv);
   const { command, flags, positionals } = parsed;
@@ -496,6 +549,7 @@ async function main(argv, runtime = {}) {
     }
     await maybePickHudAccent(flags, runtime, { promptForAccent: prompted === "chosen" });
     await maybePickOutputStyle(flags);
+    await maybeOfferBell(flags, runtime, { prompt: prompted === "chosen" });
     scheduleUpdateSafely(command, flags, runtime);
     return;
   }
@@ -552,4 +606,4 @@ async function main(argv, runtime = {}) {
   console.log(helpText());
 }
 
-module.exports = { COMMAND_SPECS, helpText, main, parseArgs, validateArgs };
+module.exports = { COMMAND_SPECS, helpText, main, maybeOfferBell, parseArgs, validateArgs };

package/src/lib/config.js

@@ -1,5 +1,6 @@
 const fs = require("node:fs");
 const path = require("node:path");
+const { isDeepStrictEqual } = require("node:util");
 const { parseDocument } = require("yaml");
 const { writeFileAtomic } = require("./files");
 const modelConfig = require("./modelConfig");
@@ -181,6 +182,56 @@ function setTuiAgentsNudgeConfig(text) {
   return joinLines(lines, eol, ["display:", "  tui_agents_nudge: true"]);
 }
 
+// Hermes display.bell_on_complete (default false): BEL + desktop notice when a
+// turn ends. null = unset, undefined = config.yaml does not parse.
+function readBellOnCompleteConfig(text) {
+  const str = String(text || "");
+  if (!str.trim()) return null;
+  try {
+    const document = parseDocument(str, { strict: true, uniqueKeys: true });
+    if (document.errors.length) return undefined;
+    const value = document.toJS()?.display?.bell_on_complete;
+    return value === undefined || value === null ? null : value;
+  } catch {
+    return undefined;
+  }
+}
+
+// Add `bell_on_complete: true` only when unset. Returns null, and edits
+// nothing, when the result would differ from the input by anything but that
+// one key (an odd indent, a flow map, or YAML that does not parse).
+function setBellOnCompleteConfig(text) {
+  const str = String(text || "");
+  const current = readBellOnCompleteConfig(str);
+  if (current === undefined) return null;
+  if (current !== null) return str;
+  const eol = eolOf(str);
+  const lines = str.split(/\r?\n/);
+  const block = findTopBlock(lines, "display");
+  let after;
+  if (block) {
+    openBlock(lines, block);
+    lines.splice(block.start + 1, 0, "  bell_on_complete: true");
+    after = joinLines(lines, eol);
+  } else {
+    after = joinLines(lines, eol, ["display:", "  bell_on_complete: true"]);
+  }
+  const parse = (value) => {
+    const document = parseDocument(value, { strict: true, uniqueKeys: true });
+    return document.errors.length ? undefined : document.toJS() || {};
+  };
+  const was = parse(str);
+  const now = parse(after);
+  if (!was || !now || now.display?.bell_on_complete !== true) return null;
+  delete now.display.bell_on_complete;
+  // An absent or empty (null) display block had nothing else in it.
+  if (!Object.keys(now.display).length && was.display == null) {
+    if (was.display === undefined) delete now.display;
+    else now.display = null;
+  }
+  return isDeepStrictEqual(was, now) ? after : null;
+}
+
 function clearDisplaySkinConfig(text) {
   const lines = String(text || "").split(/\r?\n/);
   const block = findTopBlock(lines, "display");
@@ -296,6 +347,7 @@ module.exports = {
   disableLitHermesConfig,
   enableLitHermesConfig,
   readConfig,
+  readBellOnCompleteConfig,
   readDisplaySkinConfig,
   readExternalSkillDirsConfig,
   readStatusBarFields,
@@ -303,6 +355,7 @@ module.exports = {
   suggestStatusBarFields,
   readOutputStyleConfig,
   readTuiAgentsNudgeConfig,
+  setBellOnCompleteConfig,
   setDisplaySkinConfig,
   setOutputStyleConfig,
   setTuiAgentsNudgeConfig,

package/src/lib/modelRoutePolicy.js

@@ -10,30 +10,36 @@ const LEGACY_SOL_MODEL = "gpt-5.6-sol";
 const LEGACY_CHILD_MODEL = "gpt-5.6-luna";
 const CHILD_EFFORT = "max";
 const GPT6_LUNA_EFFORTS = new Set(["low", "medium", "high", "xhigh", "max"]);
-const LEGACY_LUNA_EFFORTS = new Set(["high", "max"]);
+const LEGACY_LUNA_EFFORTS = GPT6_LUNA_EFFORTS;
 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],
   [PREVIOUS_SOL_MODEL, GPT6_LEAD_EFFORTS],
   [CHILD_MODEL, GPT6_LUNA_EFFORTS],
-  [LEGACY_SOL_MODEL, LEGACY_SOL_EFFORTS],
+  [LEGACY_SOL_MODEL, GPT6_LEAD_EFFORTS],
   [LEGACY_CHILD_MODEL, LEGACY_LUNA_EFFORTS],
   ["gpt-5.6", new Set(["high"])],
-  [TERRA_MODEL, TERRA_EFFORTS],
+  [TERRA_MODEL, GPT6_LEAD_EFFORTS],
 ]);
+// When only a model is given, these keep the effort they resolved to before their
+// full effort sets were listed, so widening a menu never moves a default.
+const MODEL_ONLY_EFFORTS = {
+  lead: new Map([[LEGACY_CHILD_MODEL, CHILD_EFFORT]]),
+  child: new Map([[LEGACY_SOL_MODEL, "high"]]),
+};
 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 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).
+// OpenAI rows offer every effort the live model catalog lists for each model
+// (supported_reasoning_levels), including the selectable legacy GPT-5.6 routes. Hermes
+// accepts each of them in config but may send a lower level (ultra as max; max and ultra
+// as xhigh on gpt-6.1-sol, gpt-6-sol and gpt-6-luna). xAI rows use the reasoning-capable models
+// of the Hermes 0.19 catalog (hermes_cli/models.py `_XAI_STATIC_FALLBACK`), newest first,
+// with the efforts Hermes sends to Grok before 4.6 (agent/reasoning_effort.py XAI_LEGACY_EFFORTS).
 const ROUTE_CATALOG = {
   [OPENAI_PROVIDER_ID]: {
     credentialEnv: null,
@@ -67,18 +73,25 @@ const ROUTE_CATALOG = {
             ? "balanced, lighter effort"
             : "Luna Responses effort",
       })),
-      ...["high", "xhigh"].map((effort) => ({
+      ...[...GPT6_LEAD_EFFORTS].map((effort) => ({
         effort,
         model: LEGACY_SOL_MODEL,
         note: "previous-generation Sol lead route",
       })),
-      ...["high", "xhigh", "max"].map((effort) => ({
+      ...[...GPT6_LEAD_EFFORTS].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" },
+      ...[...GPT6_LUNA_EFFORTS].map((effort) => ({
+        effort,
+        model: LEGACY_CHILD_MODEL,
+        note: effort === CHILD_EFFORT
+          ? "previous-generation balanced helper"
+          : effort === "high"
+            ? "previous-generation lighter helper"
+            : "previous-generation Luna effort",
+      })),
       { effort: "high", model: "gpt-5.6", note: "general model" },
     ],
     lead: { effort: PARENT_EFFORT, model: PARENT_MODEL },
@@ -88,11 +101,15 @@ const ROUTE_CATALOG = {
     credentialEnv: "XAI_API_KEY",
     label: "xAI Grok",
     rows: [
-      { effort: "high", model: "grok-build-0.1", note: "newest coding model (recommended lead)" },
-      { effort: "high", model: "grok-4.5", note: "flagship reasoning" },
-      { effort: "high", model: "grok-4.3", note: "fast reasoning (recommended helper)" },
-      { effort: "high", model: "grok-4.20-0309-reasoning", note: "previous reasoning generation" },
-    ],
+      ["grok-build-0.1", "newest coding model (recommended lead)"],
+      ["grok-4.5", "flagship reasoning"],
+      ["grok-4.3", "fast reasoning (recommended helper)"],
+      ["grok-4.20-0309-reasoning", "previous reasoning generation"],
+    ].flatMap(([model, note]) => ["low", "medium", "high"].map((effort) => ({
+      effort,
+      model,
+      note: effort === "high" ? note : "Grok reasoning effort",
+    }))),
     lead: { effort: "high", model: "grok-build-0.1" },
     helper: { effort: "high", model: "grok-4.3" },
   },
@@ -137,28 +154,19 @@ function inspectEffectiveRouteSafety(document, expectedProvider) {
     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: isAstra
           ? "astra_effort_unsupported"
-          : isLegacyLunaXhigh
-            ? "conflicting_luna_xhigh"
-            : isLuna
-              ? "luna_effort_below_high"
-              : route.model === TERRA_MODEL
-                ? "terra_effort_below_high"
-                : "model_effort_unsupported",
+          : isLuna
+            ? "luna_effort_unsupported"
+            : "model_effort_unsupported",
         code: UNSAFE_ROUTE_CODE,
         observedSource: `${route.route} model, effort, and provider config`,
         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(", ")}`,
+          : isLuna
+            ? `${route.route} Luna effort is unsupported; choose one of: ${[...modelEfforts].join(", ")}`
+            : `${route.route} ${route.model} effort is unsupported or missing; choose one of: ${[...modelEfforts].join(", ")}`,
         route: route.route,
         status: "blocked",
       };
@@ -202,9 +210,6 @@ function resolveRow(provider, role, model, effort) {
   const hasModel = model !== undefined;
   const hasEffort = effort !== undefined;
   const resolvedModel = hasModel ? String(model) : preset.model;
-  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) {
     const known = PROVIDER_IDS.some((id) => ROUTE_CATALOG[id].rows.some((row) => row.model === resolvedModel));
@@ -215,7 +220,9 @@ function resolveRow(provider, role, model, effort) {
   // An explicitly selected model keeps that model's cataloged preset effort
   // when no effort flag is supplied. This matters for Astra: its recommended
   // lead row is xhigh, while its catalog is intentionally listed low-first.
-  const modelDefault = rowsForModel.find((row) => row.effort === preset.effort)?.effort ?? rowsForModel[0].effort;
+  const modelDefault = MODEL_ONLY_EFFORTS[role]?.get(resolvedModel)
+    ?? rowsForModel.find((row) => row.effort === preset.effort)?.effort
+    ?? rowsForModel[0].effort;
   const resolvedEffort = hasEffort ? String(effort) : (hasModel ? modelDefault : preset.effort);
   if (!rowsForModel.some((row) => row.effort === resolvedEffort)) {
     throw new Error(`${role} effort ${resolvedEffort} is not offered for ${resolvedModel}; choose one of: ${rowsForModel.map((row) => row.effort).join(", ")}`);

package/src/lib/skins.js

@@ -1,6 +1,7 @@
 const fs = require("node:fs");
 const path = require("node:path");
 const { colorMode, skinLogo, microLogo } = require("./litMark");
+const { writeFileAtomic } = require("./files");
 
 // LitHermes HUD accents — 10 presets that drive Hermes' native skin engine.
 // Each becomes ~/.hermes/skins/lithermes-<accent>.yaml; activated via
@@ -179,7 +180,31 @@ function recolorMarkup(rows, palette) {
 // get_color path, dark_colors/light_colors are the TUI polarity pair, and
 // spinner wings must be [left, right] pairs (get_spinner_wings drops single
 // glyphs, so the brief's flat wing list is shipped as two pairs).
-function renderSkinYaml(entry) {
+// Hermes picks one face at random for each thinking step and each tool call,
+// so the four frames read as a flame moving through "lit" across a turn.
+const FLAME_FACES = '["(🔥 lit)", "( 🔥lit)", "(lit🔥 )", "(lit 🔥)"]';
+const SPINNER_LINES = Object.freeze([
+  `  waiting_faces: ${FLAME_FACES}`,
+  `  thinking_faces: ${FLAME_FACES}`,
+  "  thinking_verbs: [igniting, lit-looping, planning, verifying, gathering evidence, checking criteria, reviewing]",
+]);
+// Spinner blocks earlier releases wrote, newest first. A preset whose spinner
+// block still matches one of them byte for byte gets the flame faces on the
+// next install; everything else in the file, and any edited spinner, stays.
+const SHIPPED_SPINNERS = Object.freeze([
+  Object.freeze([
+    '  waiting_faces: ["(lit)", "(◜)", "(◝)", "(◞)", "(◟)"]',
+    '  thinking_faces: ["(lit)", "(✦)", "(◇)", "(⌁)"]',
+    "  thinking_verbs: [lit-looping, planning, verifying, gathering evidence, checking criteria, reviewing]",
+  ]),
+  Object.freeze([
+    '  waiting_faces: ["🔥", "🔥", "🔥", "🔥"]',
+    "  thinking_verbs: [igniting, forging, burning, tempering]",
+  ]),
+]);
+const spinnerBlock = (lines) => ["spinner:", ...lines, "  wings:"].join("\n");
+
+function renderSkinYaml(entry, { spinner = SPINNER_LINES } = {}) {
   const h = entry.hex;
   const theme = entry.palette;
   const colorBlocks = theme
@@ -200,9 +225,7 @@ function renderSkinYaml(entry) {
     `description: LitHermes ${entry.label} accent HUD`,
     ...colorBlocks,
     "spinner:",
-    '  waiting_faces: ["(lit)", "(◜)", "(◝)", "(◞)", "(◟)"]',
-    '  thinking_faces: ["(lit)", "(✦)", "(◇)", "(⌁)"]',
-    "  thinking_verbs: [lit-looping, planning, verifying, gathering evidence, checking criteria, reviewing]",
+    ...spinner,
     "  wings:",
     '    - ["◜", "◝"]',
     '    - ["◞", "◟"]',
@@ -249,11 +272,22 @@ function installSkins(hermesHome) {
       written.push(file);
     } catch (error) {
       if (error.code !== "EEXIST") throw error;
+      if (upgradeShippedSpinner(file)) written.push(file);
     }
   }
   return written;
 }
 
+function upgradeShippedSpinner(file) {
+  const stat = fs.lstatSync(file, { throwIfNoEntry: false });
+  if (!stat || !stat.isFile() || stat.size > 64 * 1024) return false;
+  const text = fs.readFileSync(file, "utf8");
+  const shipped = SHIPPED_SPINNERS.map(spinnerBlock).find((block) => text.split(block).length === 2);
+  if (!shipped) return false;
+  writeFileAtomic(file, text.replace(shipped, spinnerBlock(SPINNER_LINES)), "utf8");
+  return true;
+}
+
 function hexToRgb(hex) {
   const m = /^#?([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})$/i.exec(String(hex));
   if (!m) return null;
@@ -286,6 +320,7 @@ module.exports = {
   skinName,
   skinsDir,
   renderSkinYaml,
+  SHIPPED_SPINNERS,
   findAccent,
   installSkins,
   hexToRgb,