genshin-persona 3.7.0 → 3.9.0

package/hooks/hooks.json

@@ -1,5 +1,5 @@
 {
   "hooks": {
-    "SessionStart": [{ "hooks": [{ "type": "command", "command": "node \"${CLAUDE_PLUGIN_ROOT}/scripts/pick.ts\"" }] }]
+    "SessionStart": [{ "hooks": [{ "type": "command", "command": "node \"${CLAUDE_PLUGIN_ROOT}/scripts/pick.mjs\"" }] }]
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "genshin-persona",
-  "version": "3.7.0",
+  "version": "3.9.0",
   "description": "A Claude Code plugin that speaks as the Genshin Impact character whose birthday is nearest: an answer opens with one spoken line in the character's voice and the rest is plain, a joke or a hello is spoken whole, and every line is read aloud in the character's own cloned voice as the reply is written.",
   "keywords": [
     "claude-code",
@@ -34,7 +34,9 @@
   ],
   "type": "module",
   "imports": {
-    "#src/*": "./src/*.ts"
+    "#src/*": "./src/*.ts",
+    "#src/*.json": "./src/*.json",
+    "#scripts/*": "./scripts/*.ts"
   },
   "publishConfig": {
     "access": "public"
@@ -50,10 +52,12 @@
   "dependencies": {
     "@typesafe-ai/sdk": "^0.6.0",
     "@wasm-audio-decoders/ogg-vorbis": "^0.1.20",
-    "genshin-db": "^5.2.14"
+    "citty": "^0.2.2",
+    "genshin-db": "^5.2.14",
+    "tsx": "^4.23.15"
   },
   "engines": {
     "node": ">=26.10.0"
   },
-  "gitHead": "7fd06688d06adf6dafff4bd869cd7a33d8028688"
+  "gitHead": "f9f6208c35e6cff4ed33910623c798cd88f09301"
 }

package/scripts/genshin.mjs

@@ -0,0 +1,5 @@
+// Node strips types and takes no `enum`, so the entry registers tsx before it loads its TypeScript
+import { register } from "tsx/esm/api";
+
+register();
+await import("#scripts/genshin");

package/scripts/genshin.ts

@@ -1,424 +1,15 @@
-import type { CardedCharacter } from "#src/models/CardedCharacter";
-import type { Character } from "#src/models/Character";
-
-import { GenshinVerb, GenshinVerbs } from "#src/models/GenshinVerb";
-import { VoiceRequestType } from "#src/models/VoiceRequestType";
-import { VoiceStatus } from "#src/models/VoiceStatus";
-import { checkHasWeights } from "#src/services/checkHasWeights";
-import { checkIsMuted } from "#src/services/checkIsMuted";
-import { checkIsOwnVoiceLine } from "#src/services/checkIsOwnVoiceLine";
-import { checkIsPluginHookEntry } from "#src/services/checkIsPluginHookEntry";
-import { checkIsPluginSpinner } from "#src/services/checkIsPluginSpinner";
-import { checkIsPluginStatusLine } from "#src/services/checkIsPluginStatusLine";
-import { checkIsRuntimeInstalled } from "#src/services/checkIsRuntimeInstalled";
-import { checkIsVoiceLanguage } from "#src/services/checkIsVoiceLanguage";
-import { checkIsVolume } from "#src/services/checkIsVolume";
-import { connectVoiceServer } from "#src/services/connectVoiceServer";
-import {
-  CARD_DETAIL_SEPARATOR,
-  DEFAULT_LANGUAGE,
-  MAX_VOLUME,
-  MODELS_DIRECTORY,
-  RUNTIME_MANIFEST_PATH,
-  SESSION_ID_ENVIRONMENT_VARIABLE,
-  STATUS_LAUNCHER_PATH,
-  STATUS_SCRIPT_PATH,
-  VOICE_CPU_DEVICE,
-  VOICE_LOG_PATH,
-  VOICE_PROOF_TEXT,
-  VOICE_STATUS_SEPARATOR,
-  VoiceLanguageNameMap,
-} from "#src/services/constants";
-import { createVoiceProgressPrinter } from "#src/services/createVoiceProgressPrinter";
-import { createVoiceSynthesizer } from "#src/services/createVoiceSynthesizer";
-import { deletePin } from "#src/services/deletePin";
-import { deleteVoiceDevice } from "#src/services/deleteVoiceDevice";
-import { deleteVoiceState } from "#src/services/deleteVoiceState";
-import { findCharacterByName } from "#src/services/findCharacterByName";
-import { formatCard } from "#src/services/formatCard";
-import { getCanonicalLanguage } from "#src/services/getCanonicalLanguage";
-import { getCard } from "#src/services/getCard";
-import { getLanguageDisplayName } from "#src/services/getLanguageDisplayName";
-import { getSettingsWithoutPluginEntries } from "#src/services/getSettingsWithoutPluginEntries";
-import { getSettingsWithStatusLine } from "#src/services/getSettingsWithStatusLine";
-import { getSpeechRequest } from "#src/services/getSpeechRequest";
-import { getWarmRequest } from "#src/services/getWarmRequest";
-import { installVoiceRuntime } from "#src/services/installVoiceRuntime";
-import { pickCurrentCharacter } from "#src/services/pickCurrentCharacter";
-import { readCardedRoster } from "#src/services/readCardedRoster";
-import { readCharacterReference } from "#src/services/readCharacterReference";
+import { GenshinVerbs } from "#src/models/GenshinVerb";
+import { genshinCommand } from "#src/services/cli/commands/genshinCommand";
 import { readInterfaceLanguage } from "#src/services/readInterfaceLanguage";
-import { readLanguageNames } from "#src/services/readLanguageNames";
 import { readLocalization } from "#src/services/readLocalization";
-import { readPersonaCard } from "#src/services/readPersonaCard";
-import { readPin } from "#src/services/readPin";
-import { readReplyLanguage } from "#src/services/readReplyLanguage";
-import { readRoster } from "#src/services/readRoster";
-import { readSpinner } from "#src/services/readSpinner";
-import { readUserSettings } from "#src/services/readUserSettings";
-import { readVoiceDevice } from "#src/services/readVoiceDevice";
-import { readVoiceLanguage } from "#src/services/readVoiceLanguage";
-import { readVoiceLines } from "#src/services/readVoiceLines";
-import { readVoiceRuntime } from "#src/services/readVoiceRuntime";
-import { readVolume } from "#src/services/readVolume";
-import { recordSessionCharacter } from "#src/services/recordSessionCharacter";
-import { resolveSessionCharacter } from "#src/services/resolveSessionCharacter";
-import { sendVoiceRequest } from "#src/services/sendVoiceRequest";
-import { setMuted } from "#src/services/setMuted";
-import { writeInterfaceLanguage } from "#src/services/writeInterfaceLanguage";
-import { writeLauncher } from "#src/services/writeLauncher";
-import { writePin } from "#src/services/writePin";
-import { writeReplyLanguage } from "#src/services/writeReplyLanguage";
-import { writeSessionSpinner } from "#src/services/writeSessionSpinner";
-import { writeSpeakHook } from "#src/services/writeSpeakHook";
-import { writeSpinner } from "#src/services/writeSpinner";
-import { writeUserSettings } from "#src/services/writeUserSettings";
-import { writeVoiceLanguage } from "#src/services/writeVoiceLanguage";
-import { writeVolume } from "#src/services/writeVolume";
-
-const [verb, ...nameParts] = process.argv.slice(2);
-const name = nameParts.join(" ");
-const language = readInterfaceLanguage();
-const roster = readRoster(language);
-const { locale, strings } = await readLocalization(language);
-// A choice a verb offers is a list in the interface language's own punctuation, which the runtime knows
-const listFormat = new Intl.ListFormat(locale, { type: "disjunction" });
-const today = Temporal.Now.plainDateISO();
-const getRosterLine = ({ birthday, displayElement, displayName, region, title, version }: Character) =>
-  [displayName, title, displayElement, region, birthday, `v${version}`].filter(Boolean).join(CARD_DETAIL_SEPARATOR);
-// An authoring queue prints the characters that meet it newest first, so a patch's arrivals are at the top
-const printQueue = async (checkIsQueued: (cardedCharacter: CardedCharacter) => boolean) => {
-  const cardedRoster = await readCardedRoster(roster);
-  for (const { character } of cardedRoster
-    .filter((cardedCharacter) => checkIsQueued(cardedCharacter))
-    .toSorted(
-      ({ character: a }, { character: b }) =>
-        b.version.localeCompare(a.version, undefined, { numeric: true }) || a.name.localeCompare(b.name),
-    ))
-    console.log(getRosterLine(character));
-};
-// The character a verb names by its argument, or nothing once the argument names none — which every such verb answers
-// The same way, so the refusal and its exit code are said here rather than at each
-const readNamedCharacter = () => {
-  const character = findCharacterByName(roster, name);
-  if (!character) {
-    console.error(strings.noCharacterNamed(name));
-    process.exitCode = 1;
-  }
-
-  return character;
-};
-// Empty from a shell, where the tool set nothing
-const sessionId = process.env[SESSION_ID_ENVIRONMENT_VARIABLE] ?? "";
-// The language is read again rather than closed over, because the `language` verb changes it and then prints the
-// Card: the card a verb prints is always in the language in force at the end of that verb
-const printCard = async (character: Character) => {
-  const localization = await readLocalization(readInterfaceLanguage());
-  const card = getCard(character, today, localization, await readPersonaCard(character.name));
-  console.log(formatCard(card));
-};
-// This session's character when run inside one, else the pin, else a fresh pick: the resolution the start hook runs,
-// So `today` answers who is speaking now. Under the lore pick a fresh ask may answer differently, which is the point
-// Of it, and a fresh ask the tier did not answer says so beside the birthday pick that stood in
-const getCurrentCharacter = async () => {
-  const pin = readPin();
-  if (pin && !findCharacterByName(roster, pin.name)) console.log(strings.pinIgnored(pin.name));
-
-  const pick = await resolveSessionCharacter(roster, sessionId, today);
-  if (pick?.loreFailure) console.log(strings.lorePickUnanswered(pick.loreFailure));
-  return pick?.character;
-};
-// The session speaks as the character from the reply that relays the card: its record is rewritten so every later
-// Start, the status line and the speech hook agree. The spinner is not rewritten here: the tool read its keys when
-// This session started, so a write now reaches only some other session, and a switch scoped to this one must not
-const switchSessionCharacter = async (character: Character) => {
-  recordSessionCharacter(character, sessionId, today.toString());
-  await printCard(character);
-};
-// Every knob in one read, for the verbs that report rather than change: the status verb, and either language verb
-// Given no argument
-const getStatusReport = async () => {
-  const pin = readPin();
-  const pick = sessionId ? await resolveSessionCharacter(roster, sessionId, today) : undefined;
-  const replyLanguage = readReplyLanguage();
-  const settings = readUserSettings();
-  return {
-    displayName: pick?.character.displayName ?? pin?.displayName ?? "",
-    interfaceLanguage: getLanguageDisplayName(language, language),
-    isFromSessionRecord: Boolean(pick),
-    isMuted: checkIsMuted(),
-    isPluginSpeakHook: settings.hooks?.MessageDisplay?.some((entry) => checkIsPluginHookEntry(entry)) ?? false,
-    isPluginSpinner: checkIsPluginSpinner(settings),
-    isPluginStatusLine: checkIsPluginStatusLine(settings.statusLine),
-    isReplyLanguageCascaded: !replyLanguage,
-    isRuntimeInstalled: checkIsRuntimeInstalled(),
-    pinnedName: pin?.name ?? "",
-    replyLanguage: getLanguageDisplayName(replyLanguage ?? language, language),
-    voiceDevice: readVoiceDevice(),
-    voiceLanguage: readVoiceLanguage(),
-    volume: readVolume(),
-  };
-};
-
-switch (verb) {
-  case GenshinVerb.Language: {
-    const languageNames = readLanguageNames();
-    // Each language is offered in its own words beside the word a person types for it, and either resolves
-    const offered = listFormat.format(
-      languageNames.map((languageName) => {
-        const ownName = getLanguageDisplayName(languageName, languageName);
-        return ownName === languageName ? languageName : `${languageName} (${ownName})`;
-      }),
-    );
-    if (!name) {
-      console.log(strings.status(await getStatusReport()));
-      console.log(strings.languageMustBeOneOf(offered));
-      break;
-    }
-
-    const canonicalLanguage = getCanonicalLanguage(languageNames, name);
-    if (!canonicalLanguage) {
-      console.error(strings.languageMustBeOneOf(offered));
-      process.exitCode = 1;
-      break;
-    }
-
-    writeInterfaceLanguage(canonicalLanguage);
-    // Everything downstream reads the language afresh: the roster in it, which builds that language's cache, the
-    // Words that are ours in it, and the session's record and spinner, whose name is drawn from it
-    const localizedRoster = readRoster(canonicalLanguage);
-    const { strings: localizedStrings } = await readLocalization(canonicalLanguage);
-    const pick = await resolveSessionCharacter(localizedRoster, sessionId, today);
-    const character = pick?.character;
-    if (character && sessionId) {
-      recordSessionCharacter(character, sessionId, today.toString());
-      await writeSessionSpinner(character, await readPersonaCard(character.name), canonicalLanguage);
-    }
-
-    const pin = readPin();
-    const pinnedCharacter = findCharacterByName(localizedRoster, pin?.name ?? "");
-    if (pinnedCharacter) writePin(pinnedCharacter);
-    console.log(localizedStrings.interfaceLanguageSet(getLanguageDisplayName(canonicalLanguage, canonicalLanguage)));
-    // A multi-gigabyte download is never a side effect of a labels setting, so the dub is reported on and left
-    // Alone. Three states and three answers: no dub of this language, one that is not installed, and one that
-    // Already is — which is the quiet case, since there is nothing for the person to do about it
-    const [matchingDub] =
-      Object.entries(VoiceLanguageNameMap).find(([, languageName]) => languageName === canonicalLanguage) ?? [];
-    if (canonicalLanguage !== DEFAULT_LANGUAGE)
-      if (!matchingDub) console.log(localizedStrings.voiceLanguageUnavailable);
-      else if (matchingDub !== readVoiceLanguage()) console.log(localizedStrings.voiceLanguageAvailable(matchingDub));
-
-    if (character) await printCard(character);
-    break;
-  }
-  case GenshinVerb.Lines: {
-    const character = readNamedCharacter();
-    if (!character) break;
-
-    console.log(`${getRosterLine(character)}\n${character.description}`);
-    const voiceLines = await readVoiceLines(character.name, language);
-    for (const { text, title } of voiceLines.filter((line) => checkIsOwnVoiceLine(line)))
-      console.log(`- ${title}: ${text}`);
-    break;
-  }
-  case GenshinVerb.Mute:
-    setMuted(true);
-    console.log(strings.muted);
-    break;
-  case GenshinVerb.Pin: {
-    const pinnedCharacter = readNamedCharacter();
-    if (!pinnedCharacter) break;
-
-    writePin(pinnedCharacter);
-    // The pinned character is what every later session speaks as, so the spinner may follow where `setup` opted it in
-    await writeSessionSpinner(pinnedCharacter, await readPersonaCard(pinnedCharacter.name), language);
-    if (sessionId) {
-      await switchSessionCharacter(pinnedCharacter);
-      console.log(strings.pinnedInSession);
-      break;
-    }
-
-    await printCard(pinnedCharacter);
-    console.log(strings.pinned);
-    break;
-  }
-  case GenshinVerb.Reply: {
-    if (!name) {
-      console.log(strings.status(await getStatusReport()));
-      break;
-    }
-    // Anything the model can write is a legal reply language, so this is not held to the data package's fifteen;
-    // The canonical spelling is taken where it names one of them, so the common case reads as the language verb's
-    const replyLanguage = getCanonicalLanguage(readLanguageNames(), name) ?? name;
-    writeReplyLanguage(replyLanguage);
-    console.log(strings.replyLanguageSet(getLanguageDisplayName(replyLanguage, language)));
-    if (replyLanguage !== DEFAULT_LANGUAGE && readVoiceLanguage()) console.log(strings.replyLanguageSilencesVoice);
-    break;
-  }
-  case GenshinVerb.Roster:
-    for (const character of roster) console.log(getRosterLine(character));
-    break;
-  case GenshinVerb.Setup: {
-    writeLauncher(STATUS_LAUNCHER_PATH, STATUS_SCRIPT_PATH);
-    const userSettings = readUserSettings();
-    const settings = getSettingsWithStatusLine(userSettings);
-    writeUserSettings(settings);
-    const character = await getCurrentCharacter();
-    if (character) writeSpinner(await readSpinner(character, await readPersonaCard(character.name), language));
-    console.log(checkIsPluginStatusLine(settings.statusLine) ? strings.setupDone : strings.setupStatusLineKept);
-    break;
-  }
-  case GenshinVerb.Status:
-    console.log(strings.status(await getStatusReport()));
-    break;
-  case GenshinVerb.Teardown: {
-    const userSettings = readUserSettings();
-    const settings = getSettingsWithoutPluginEntries(userSettings);
-    writeUserSettings(settings);
-    await deleteVoiceState();
-    console.log(strings.teardownDone);
-    break;
-  }
-  case GenshinVerb.Today: {
-    const character = await getCurrentCharacter();
-    if (character) await printCard(character);
-    break;
-  }
-  case GenshinVerb.Uncarded:
-    await printQueue(({ personaCard }) => !personaCard);
-    break;
-  case GenshinVerb.Unmute:
-    setMuted(false);
-    console.log(strings.unmuted);
-    break;
-  case GenshinVerb.Unpin: {
-    deletePin();
-    const pick = sessionId ? await pickCurrentCharacter(roster, today) : undefined;
-    if (!pick) {
-      console.log(strings.pinRemoved);
-      break;
-    }
-
-    if (pick.loreFailure) console.log(strings.lorePickUnanswered(pick.loreFailure));
-    await switchSessionCharacter(pick.character);
-    console.log(strings.pinRemovedInSession);
-    break;
-  }
-  case GenshinVerb.Untranslated: {
-    // The queue the language modules are filled from, the way `unverbed` is the queue the cards' verbs are: who has
-    // No gerunds in this language, or a card whose greeting it has not written. English reads both off the cards,
-    // So it is never behind
-    if (language === DEFAULT_LANGUAGE) break;
-
-    const { characters } = await readLocalization(language);
-    await printQueue(({ character: { name: characterName }, personaCard }) => {
-      const localizedPersonaCard = characters[characterName];
-      return !localizedPersonaCard?.verbs || (Boolean(personaCard) && !localizedPersonaCard.greeting);
-    });
-    break;
-  }
-  case GenshinVerb.Unverbed:
-    await printQueue(({ personaCard }) => personaCard?.verbs.length === 0);
-    break;
-  case GenshinVerb.Use: {
-    const character = readNamedCharacter();
-    if (!character) break;
-
-    if (!sessionId) {
-      console.error(strings.noSession);
-      process.exitCode = 1;
-      break;
-    }
-
-    await switchSessionCharacter(character);
-    console.log(strings.usingInSession);
-    break;
-  }
-  case GenshinVerb.Voice: {
-    if (!name) {
-      const voiceLanguage = readVoiceLanguage();
-      console.log(
-        voiceLanguage
-          ? strings.voiceStatus(checkIsRuntimeInstalled(), voiceLanguage, readVoiceDevice(), VOICE_LOG_PATH)
-          : strings.voiceUnset,
-      );
-      break;
-    }
-
-    if (!checkIsVoiceLanguage(name)) {
-      console.error(strings.voiceLanguageMustBeOneOf(listFormat.format(Object.keys(VoiceLanguageNameMap))));
-      process.exitCode = 1;
-      break;
-    }
-    // The proof walks the device ladder from the top, so a rung this machine once demoted is tried again here and
-    // Nowhere else: the rung on file is cleared, and a synthesizer still running — on that rung, or on the runtime
-    // Being replaced — is stopped, so the one the warm spawns loads afresh
-    deleteVoiceDevice();
-    await connectVoiceServer({ type: VoiceRequestType.Stop });
-    if (checkIsRuntimeInstalled()) console.log(strings.runtimeInstalled);
-    else {
-      console.log(strings.runtimeInstalling);
-      if (!installVoiceRuntime()) {
-        console.error(strings.runtimeInstallFailed);
-        process.exitCode = 1;
-        break;
-      }
-    }
-    // The runtime's own loader fetches what it is asked to load into the models directory, so the weights are
-    // Downloaded by loading the engine once here — with progress, which the detached synthesizer cannot print —
-    // And the synthesizer then loads them from the cache inside a hook's budget. A cache already holding them skips
-    // The load, since the rung the engine speaks on is the proof's to report
-    if (checkHasWeights(MODELS_DIRECTORY)) console.log(strings.weightsPresent);
-    else {
-      const runtime = readVoiceRuntime(RUNTIME_MANIFEST_PATH);
-      const synthesizer = await createVoiceSynthesizer(runtime, MODELS_DIRECTORY, {
-        onFallback: console.log,
-        onProgress: createVoiceProgressPrinter(),
-      });
-      console.log(
-        synthesizer.device === VOICE_CPU_DEVICE ? strings.weightsOnCpu : strings.weightsOnDevice(synthesizer.device),
-      );
-    }
-    // The dub on disk is the gate every spoken reply passes, so it is written only where this run proved the
-    // Voice — a setup that failed after it leaves the replies silent rather than broken in the hooks' silence
-    const character = await getCurrentCharacter();
-    if (!character) {
-      writeVoiceLanguage(name);
-      writeSpeakHook();
-      console.log(strings.voiceLanguageWritten(name));
-      break;
-    }
-
-    const personaCard = await readPersonaCard(character.name);
-    if (!readCharacterReference(character.name, personaCard)) console.log(strings.noReference(character.displayName));
-
-    const warmed = await sendVoiceRequest(getWarmRequest(character.name, personaCard, name));
-    const [status, device] = warmed.split(VOICE_STATUS_SEPARATOR);
-    if (status !== VoiceStatus.Ok) {
-      console.error(strings.warmRequestUnanswered(status || "unreachable", VOICE_LOG_PATH));
-      process.exitCode = 1;
-      break;
-    }
-
-    writeVoiceLanguage(name);
-    writeSpeakHook();
-    await sendVoiceRequest(
-      getSpeechRequest(VoiceRequestType.Speak, character.name, personaCard, name, [VOICE_PROOF_TEXT]),
-    );
-    console.log(strings.spoke(character.displayName, device ?? ""));
-    break;
-  }
-  case GenshinVerb.Volume:
-    if (!checkIsVolume(name)) {
-      console.error(strings.volumeMustBeWholeNumber(MAX_VOLUME));
-      process.exitCode = 1;
-      break;
-    }
+import { runMain } from "citty";
 
-    writeVolume(name);
-    console.log(strings.volumeSet(name));
-    break;
-  default:
+// Every line the plugin prints is in the interface language, so a verb it does not know, or none, or a request for help,
+// Is answered with its own usage line, and exits before citty would add an English one of its own
+await runMain(genshinCommand, {
+  showUsage: async () => {
+    const { strings } = await readLocalization(readInterfaceLanguage());
     console.error(strings.usage(GenshinVerbs.join(" | ")));
-    process.exitCode = 1;
-}
+    process.exit(1);
+  },
+});

package/scripts/pick.mjs

@@ -0,0 +1,5 @@
+// Node strips types and takes no `enum`, so the entry registers tsx before it loads its TypeScript
+import { register } from "tsx/esm/api";
+
+register();
+await import("#scripts/pick");

package/scripts/speak.mjs

@@ -0,0 +1,5 @@
+// Node strips types and takes no `enum`, so the entry registers tsx before it loads its TypeScript
+import { register } from "tsx/esm/api";
+
+register();
+await import("#scripts/speak");

package/scripts/spinner.mjs

@@ -0,0 +1,5 @@
+// Node strips types and takes no `enum`, so the entry registers tsx before it loads its TypeScript
+import { register } from "tsx/esm/api";
+
+register();
+await import("#scripts/spinner");

package/scripts/spinner.ts

@@ -4,13 +4,28 @@ import { readPersonaCard } from "#src/services/readPersonaCard";
 import { readRoster } from "#src/services/readRoster";
 import { registerQuietExit } from "#src/services/registerQuietExit";
 import { writeSessionSpinner } from "#src/services/writeSessionSpinner";
+import { defineCommand, runMain } from "citty";
 
 // Spawned detached by the session-start hook, which must not wait on it: this session's character's lines are read
 // And the spinner rewritten while the person reads the card, where `setup` opted the settings in. The character
 // Arrives as the English name, which is the identity, and the roster it is looked up in is the interface
 // Language's — so the label written is the name that language spells them by
 registerQuietExit();
-const [name = ""] = process.argv.slice(2);
-const language = readInterfaceLanguage();
-const character = name ? findCharacterByName(readRoster(language), name) : undefined;
-if (character) await writeSessionSpinner(character, await readPersonaCard(character.name), language);
+await runMain(
+  defineCommand({
+    args: {
+      name: {
+        default: "",
+        description: "The session's character, by English name",
+        required: false,
+        type: "positional",
+      },
+    },
+    meta: { description: "Rewrite the spinner under the session's character", name: "spinner" },
+    run: async ({ args }) => {
+      const language = readInterfaceLanguage();
+      const character = args.name ? findCharacterByName(readRoster(language), args.name) : undefined;
+      if (character) await writeSessionSpinner(character, await readPersonaCard(character.name), language);
+    },
+  }),
+);

package/scripts/status.mjs

@@ -0,0 +1,5 @@
+// Node strips types and takes no `enum`, so the entry registers tsx before it loads its TypeScript
+import { register } from "tsx/esm/api";
+
+register();
+await import("#scripts/status");

package/scripts/voice.mjs

@@ -0,0 +1,5 @@
+// Node strips types and takes no `enum`, so the entry registers tsx before it loads its TypeScript
+import { register } from "tsx/esm/api";
+
+register();
+await import("#scripts/voice");

package/skills/genshin/SKILL.md

@@ -9,7 +9,7 @@ user-invocable: false
 The plugin picks a character at every session start — by lore through a typed decision when a TypeSafe key is configured, by the nearest birthday otherwise; the verbs below are how the user reads and overrides that. Each verb is its own slash command, `/genshin-persona:<verb>`, for the user to type; this skill is how a request put in words reaches one. Every verb runs the plugin's script and relays its output — the roster is game data the script reads, and nothing about it is known without running it.
 
 ```bash
-node "${CLAUDE_PLUGIN_ROOT}/scripts/genshin.ts" <verb> [name]
+node "${CLAUDE_PLUGIN_ROOT}/scripts/genshin.mjs" <verb> [name]
 ```
 
 | Asked for                                                              | Verb                |

package/skills/genshin-author/SKILL.md

@@ -12,9 +12,9 @@ A character with no card is fully usable: the session-start hook prints the name
 Newest first, so the queue starts with whoever a player has heard most recently:
 
 ```bash
-node "${CLAUDE_PLUGIN_ROOT}/scripts/genshin.ts" uncarded       # no card at all
-node "${CLAUDE_PLUGIN_ROOT}/scripts/genshin.ts" unverbed       # a card with no verbs
-node "${CLAUDE_PLUGIN_ROOT}/scripts/genshin.ts" untranslated   # no gerunds or greeting in the interface language
+node "${CLAUDE_PLUGIN_ROOT}/scripts/genshin.mjs" uncarded       # no card at all
+node "${CLAUDE_PLUGIN_ROOT}/scripts/genshin.mjs" unverbed       # a card with no verbs
+node "${CLAUDE_PLUGIN_ROOT}/scripts/genshin.mjs" untranslated   # no gerunds or greeting in the interface language
 ```
 
 The third queue is a language's rather than a card's, and it is empty under English, where the gerunds and the greeting are read off the cards themselves. Under any other language they live in one module per language at `src/localizations/<language>.ts`, named the way a card is named for its character: a `characters` map keyed by the character's English name, each entry the person's half of that card — `verbs` and `greeting`, either present once written — beside that language's base Teyvat verbs. A character with no verbs in a module that exists shows the base verbs alone rather than the card's English ones behind localized ones; a language with no module at all inherits English base verbs, so the cards' gerunds show there too. A character with no greeting is greeted in the card's own words, since one line in another script is a queue item where a spinner mixing two is broken. Either way the queue draining is what fills a spinner and a welcome out and never what stops them working.
@@ -83,7 +83,7 @@ The full reasoning — how a reference is chosen and what its likeness number is
 A line is drawn from the character's own in-game lines and story, and one command prints them — the description, then every line the game-data dependency carries, and when it carries none yet, the same lines read off the community wiki's voice-over page for the interface language, which the wiki keeps for the four dubs:
 
 ```bash
-node "${CLAUDE_PLUGIN_ROOT}/scripts/genshin.ts" lines <name>
+node "${CLAUDE_PLUGIN_ROOT}/scripts/genshin.mjs" lines <name>
 ```
 
 A card is described **in our words** — never a quoted line, never a catchphrase copied verbatim, never a lyric, and never a line reworded closely enough to be recognised. The repository holds no text, image or audio lifted from the game, and a card is the one place that rule is tested by hand. An invented mannerism is not a habit: if the character's lines do not show it, it does not go in, however well it would read.

package/skills/language/SKILL.md

@@ -8,7 +8,7 @@ disable-model-invocation: true
 # Language
 
 ```bash
-node "${CLAUDE_PLUGIN_ROOT}/scripts/genshin.ts" language $ARGUMENTS
+node "${CLAUDE_PLUGIN_ROOT}/scripts/genshin.mjs" language $ARGUMENTS
 ```
 
 Relay its lines as written. The card it prints is the session's card from this reply on.

package/skills/mute/SKILL.md

@@ -7,7 +7,7 @@ disable-model-invocation: true
 # Mute
 
 ```bash
-node "${CLAUDE_PLUGIN_ROOT}/scripts/genshin.ts" mute
+node "${CLAUDE_PLUGIN_ROOT}/scripts/genshin.mjs" mute
 ```
 
 Relay its lines as written.

package/skills/pin/SKILL.md

@@ -8,7 +8,7 @@ disable-model-invocation: true
 # Pin
 
 ```bash
-node "${CLAUDE_PLUGIN_ROOT}/scripts/genshin.ts" pin $ARGUMENTS
+node "${CLAUDE_PLUGIN_ROOT}/scripts/genshin.mjs" pin $ARGUMENTS
 ```
 
 Relay its lines as written, and answer as the card it printed from this reply on.

package/skills/reply/SKILL.md

@@ -8,7 +8,7 @@ disable-model-invocation: true
 # Reply
 
 ```bash
-node "${CLAUDE_PLUGIN_ROOT}/scripts/genshin.ts" reply $ARGUMENTS
+node "${CLAUDE_PLUGIN_ROOT}/scripts/genshin.mjs" reply $ARGUMENTS
 ```
 
 Relay its lines as written, and write every reply in that language from this one on.

package/skills/roster/SKILL.md

@@ -7,7 +7,7 @@ disable-model-invocation: true
 # Roster
 
 ```bash
-node "${CLAUDE_PLUGIN_ROOT}/scripts/genshin.ts" roster
+node "${CLAUDE_PLUGIN_ROOT}/scripts/genshin.mjs" roster
 ```
 
 Relay its lines as written.

package/skills/setup/SKILL.md

@@ -7,7 +7,7 @@ disable-model-invocation: true
 # Setup
 
 ```bash
-node "${CLAUDE_PLUGIN_ROOT}/scripts/genshin.ts" setup
+node "${CLAUDE_PLUGIN_ROOT}/scripts/genshin.mjs" setup
 ```
 
 Relay its lines as written.

package/skills/status/SKILL.md

@@ -7,7 +7,7 @@ disable-model-invocation: true
 # Status
 
 ```bash
-node "${CLAUDE_PLUGIN_ROOT}/scripts/genshin.ts" status
+node "${CLAUDE_PLUGIN_ROOT}/scripts/genshin.mjs" status
 ```
 
 Relay its lines as written.