genshin-persona 3.7.0

package/scripts/voice.ts

@@ -0,0 +1,176 @@
+import type { AudioPlayer } from "#src/models/AudioPlayer";
+import type { PcmClip } from "#src/models/PcmClip";
+import type { SpeakerTensors } from "#src/models/SpeakerTensors";
+import type { SpeechRequest } from "#src/models/SpeechRequest";
+
+import { VoiceRequestType } from "#src/models/VoiceRequestType";
+import { VoiceStatus } from "#src/models/VoiceStatus";
+import {
+  MAX_VOLUME,
+  MESSAGE_DISPLAY_HOOK_TIMEOUT_MS,
+  MODELS_DIRECTORY,
+  RUNTIME_MANIFEST_PATH,
+  VOICE_IDLE_TIMEOUT_MS,
+  VOICE_STATUS_SEPARATOR,
+} from "#src/services/constants";
+import { createAudioPlayer } from "#src/services/createAudioPlayer";
+import { createClipDecoder } from "#src/services/createClipDecoder";
+import { createReplyQueue } from "#src/services/createReplyQueue";
+import { createVoiceSynthesizer } from "#src/services/createVoiceSynthesizer";
+import { getWavBytes } from "#src/services/getWavBytes";
+import { listenVoiceSocket } from "#src/services/listenVoiceSocket";
+import { parseVoiceRequest } from "#src/services/parseVoiceRequest";
+import { readReferenceClip } from "#src/services/readReferenceClip";
+import { readVoiceDevice } from "#src/services/readVoiceDevice";
+import { readVoiceRuntime } from "#src/services/readVoiceRuntime";
+import { writeVoiceDevice } from "#src/services/writeVoiceDevice";
+import { writeVoiceLog } from "#src/services/writeVoiceLog";
+import { createServer } from "node:net";
+
+// The address is bound before the engine loads, so a second hook finds it taken rather than loading a second engine;
+// Every failure is logged, since the hooks stay silent on its behalf
+const exit = (message: string) => {
+  writeVoiceLog(message);
+  process.exit(1);
+};
+process.on("uncaughtException", (error) => {
+  exit(error.message);
+});
+process.on("unhandledRejection", (reason) => {
+  exit(String(reason));
+});
+
+const server = createServer();
+if (!(await listenVoiceSocket(server))) process.exit(0);
+// Nothing between the bind and the connection handler below yields to the event loop: a hook connecting in such a gap
+// Is accepted by nobody and waits for an answer that never comes, so every load is started here and awaited later
+const idleTimer = setTimeout(() => {
+  process.exit(0);
+}, VOICE_IDLE_TIMEOUT_MS);
+const runtime = readVoiceRuntime(RUNTIME_MANIFEST_PATH);
+const decoderLoad = createClipDecoder();
+// The rung is written once the engine has spoken on it, since a load alone proves nothing about the sound
+let settledDevice = readVoiceDevice();
+const synthesizerLoad = createVoiceSynthesizer(runtime, MODELS_DIRECTORY, {
+  onFallback: writeVoiceLog,
+  rungName: settledDevice,
+});
+const getSpeakerKey = ({ language, name, stem }: SpeechRequest) => [language, name, stem].join("/");
+const speakers = new Map<string, SpeakerTensors>();
+// The reference is fetched, decoded and encoded once per character, dub and line per process
+const readSpeaker = async (request: SpeechRequest) => {
+  const [synthesizer, decoder] = await Promise.all([synthesizerLoad, decoderLoad]);
+  const key = getSpeakerKey(request);
+  const speaker = speakers.get(key);
+  if (speaker) return speaker;
+
+  const clip = await readReferenceClip(request.name, request.stem, request.language, decoder);
+  if (!clip) return undefined;
+
+  const encoded = await synthesizer.encodeReference(clip);
+  speakers.set(key, encoded);
+  return encoded;
+};
+// Each line is synthesized while the one before it plays; a warm has no player and speaks nothing, and a piece with
+// No line in it is only its place in the reply
+const speak = async (request: SpeechRequest, player: AudioPlayer | undefined, checkIsSuperseded: () => boolean) => {
+  if (request.lines.length === 0) return VoiceStatus.Ok;
+
+  const synthesizer = await synthesizerLoad;
+  const speaker = await readSpeaker(request);
+  if (!speaker) {
+    writeVoiceLog(`no reference for ${request.name} in ${request.language}`);
+    return VoiceStatus.Error;
+  }
+
+  const gain = request.volume / MAX_VOLUME;
+  const play = async ({ play: playAudio }: AudioPlayer, clip: PcmClip) => {
+    const audio = getWavBytes({ ...clip, samples: clip.samples.map((sample) => sample * gain) });
+    const playerFailure = await playAudio(audio);
+    if (playerFailure) writeVoiceLog(`the player did not play: ${playerFailure}`);
+  };
+  let playback: Promise<void> = Promise.resolve();
+  for (const line of request.lines) {
+    // oxlint-disable-next-line no-await-in-loop -- One device: lines synthesize and play back one after another
+    const clip = await synthesizer.synthesize(line, speaker);
+    if (!clip) {
+      // oxlint-disable-next-line no-await-in-loop -- One device: lines synthesize and play back one after another
+      await playback;
+      return VoiceStatus.Error;
+    }
+
+    if (synthesizer.device !== settledDevice) {
+      settledDevice = synthesizer.device;
+      writeVoiceDevice(settledDevice);
+    }
+
+    if (!player) continue;
+
+    // oxlint-disable-next-line no-await-in-loop -- One device: lines synthesize and play back one after another
+    await playback;
+    if (checkIsSuperseded()) return VoiceStatus.Superseded;
+
+    playback = play(player, clip);
+  }
+
+  await playback;
+  return VoiceStatus.Ok;
+};
+// The player is spawned before the first line is synthesized, so its start is paid under that synthesis rather than
+// In front of the first sound. A request that throws is dropped and keeps the engine
+const queue = createReplyQueue(async (request: SpeechRequest, checkIsSuperseded: () => boolean) => {
+  const isSpoken = request.type === VoiceRequestType.Speak && request.lines.length > 0;
+  const player = isSpoken ? createAudioPlayer() : undefined;
+  const [outcome] = await Promise.allSettled([speak(request, player, checkIsSuperseded)]);
+  await player?.close();
+  if (outcome?.status === "fulfilled") return outcome.value;
+
+  writeVoiceLog(`${request.type} failed: ${String(outcome?.reason)}`);
+  return VoiceStatus.Error;
+}, MESSAGE_DISPLAY_HOOK_TIMEOUT_MS);
+const handleLine = (line: string): Promise<VoiceStatus> => {
+  const request = parseVoiceRequest(line);
+  if (!request) return Promise.resolve(VoiceStatus.Error);
+
+  idleTimer.refresh();
+  if (request.type === VoiceRequestType.Stop) {
+    setImmediate(() => {
+      process.exit(0);
+    });
+    return Promise.resolve(VoiceStatus.Ok);
+  }
+
+  return queue(request);
+};
+
+server.on("connection", (socket) => {
+  let buffer = "";
+  socket.setEncoding("utf8");
+  const answer = async (chunk: string) => {
+    buffer += chunk;
+    if (!buffer.includes("\n")) return;
+
+    const [line = ""] = buffer.split("\n");
+    buffer = "";
+    // A line that is not JSON throws out of the parser synchronously; `Promise.try` turns that into a rejection this
+    // Answers rather than one nothing on the socket hears
+    const [outcome] = await Promise.allSettled([Promise.try(() => handleLine(line))]);
+    const status = outcome?.status === "fulfilled" ? outcome.value : VoiceStatus.Error;
+    if (outcome?.status === "rejected") writeVoiceLog(`request failed: ${outcome.reason}`);
+    const [load] = await Promise.allSettled([synthesizerLoad]);
+    const device = load?.status === "fulfilled" ? load.value.device : "";
+    socket.end(`${[status, device].filter(Boolean).join(VOICE_STATUS_SEPARATOR)}\n`);
+  };
+  // `socket.on` is a third-party slot that takes no promise. The codebase's synchronized-function helper ships in
+  // `@esposter/shared`, which this plugin's own install does not carry, and one call is no reason to add it
+  socket.on("data", (chunk: string) => {
+    // oxlint-disable-next-line typescript/no-floating-promises -- `answer` settles every outcome and ends the socket on each
+    answer(chunk);
+  });
+  // A hook, which hands its piece over and leaves before the answer
+  socket.on("error", () => {});
+});
+// Either load failing leaves the socket bound over an engine that answers nothing, since a reading awaits both, so
+// Both outcomes are read rather than the synthesizer's alone
+for (const load of await Promise.allSettled([synthesizerLoad, decoderLoad]))
+  if (load.status === "rejected") exit(`load failed: ${String(load.reason)}`);

package/skills/genshin/SKILL.md

@@ -0,0 +1,38 @@
+---
+name: genshin
+description: Apply when the user asks who the session's Genshin character is, wants the roster, wants a character for this session or pinned for every session, wants a pin removed, wants spoken replies muted, unmuted, louder or softer, wants the voice set up or its dub switched, wants the plugin's own text or its replies in another language, wants every setting reported, or wants the status line and spinner set up or removed. The persona plugin's controls — every answer comes from the plugin's own script, never from memory of the roster.
+user-invocable: false
+---
+
+# Genshin persona
+
+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]
+```
+
+| Asked for                                                              | Verb                |
+| :--------------------------------------------------------------------- | :------------------ |
+| Who the character is, the card                                         | `today`             |
+| Every character there is                                               | `roster`            |
+| One character for this session alone                                   | `use <name>`        |
+| One character for every session                                        | `pin <name>`        |
+| The pick back                                                          | `unpin`             |
+| Replies silent, or speaking again                                      | `mute`, `unmute`    |
+| Replies louder or softer, by a number to 100                           | `volume <number>`   |
+| The voice set up, or read in another dub                               | `voice <dub>`       |
+| The status line and the spinner written into user settings, or removed | `setup`, `teardown` |
+| The plugin's own text in another language                              | `language <name>`   |
+| Replies in another language, on their own                              | `reply <name>`      |
+| Every setting at once, changed by nothing                              | `status`            |
+
+Each verb's skill, `skills/<verb>/SKILL.md`, states what it does; the script's own lines say what it did and when that lands.
+
+The authoring verbs — `uncarded`, `unverbed`, `untranslated` and `lines <name>` — are the `genshin-author` skill's.
+
+`language` is the master toggle and carries the reply language with it, so a request for everything in one language is that one verb. `reply` is only for the person who wants them to disagree — labels in one language, prose in another — and either stays set once it is set on its own. The dub is neither: it says whose voice reads a reply, from a set of four, and costs an install, so `language` reports on it and never changes it.
+
+A card a verb prints is the session's card from the reply that relays it: `use`, `pin` and `unpin` switch the voice in the same reply, and only the spinner waits for the next session. A request for a character with no word on how long — "can you be Furina" — is `use`; `pin` is for a request that says every session.
+
+Answer in the character's voice as the output style asks, but relay the script's lines as written — a name, a title or a birthday is data, and a flourish added to one is an error waiting to be quoted back.

package/skills/genshin-author/SKILL.md

@@ -0,0 +1,110 @@
+---
+name: genshin-author
+description: Apply when writing, reviewing or listing the persona cards under src/personaCards/ or the per-language modules under src/localizations/ of the genshin-persona plugin — the card's shape and ceiling, the spinner verbs a person reads and the model never does, the one command that prints a character's own lines to write from, and the rule that a card says how the character speaks and never what the assistant does.
+---
+
+# Authoring a persona card
+
+A character with no card is fully usable: the session-start hook prints the name, title, element, region, the game's one-line description and the bracketed birthday note from the game data alone, and the spinner shows every line of theirs. A card adds what data cannot — how the character talks, and the verbs the spinner shows — and it is authored when someone feels like it, never as a gate on a new patch. A patch brings new characters, so the queue below refills on the same cadence as the dependency bump.
+
+## The queue
+
+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
+```
+
+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.
+
+Only what a person reads is a language's to write. The habits and the sign-off reach the model alone and are never translated — a model reading them in English answers in whatever language it was asked to, with the register intact. The greeting is the card's one line the person reads, printed by the hook as the welcome before the model has spoken, which is why it is the language's; a greeting in the module is the card's line as that character would say it in that language, in their own register, never the English line pasted through — the module's test refuses that.
+
+The birthday note's distance and every offered list are the runtime's words, through `Intl`, so a language module has no string for "today" or "tomorrow" and no joiner for a list: one `locale` covers them.
+
+## Shape
+
+One file per character at `src/personaCards/<name>.ts`, where the name is the character's in camel case — lowercased, every run of non-alphanumerics dropped and the letter after it capitalised (`Hu Tao` → `huTao.ts`, `Kamisato Ayaka` → `kamisatoAyaka.ts`). The card is a typed module, so the shape is checked where it is written rather than guessed at by a parser:
+
+```ts
+import type { PersonaCard } from "#src/models/PersonaCard";
+
+const clorinde: PersonaCard = {
+  greeting: "State your dispute. Spare the details.",
+  habits: [
+    "Terse and formal; conclusion first, one reason.",
+    "A task is a duel: opponent, rule, act.",
+    "Deflects questions about herself.",
+  ],
+  signOff: "with a courteous dismissal.",
+  verbs: ["Duelling", "Judging", "Patrolling", "Hunting"],
+  reference: "Clorinde More About Clorinde - 03",
+};
+
+export default clorinde;
+```
+
+The const carries the file's name and is exported as the default, because the loader has a path in hand and never a name. A field missing, misspelled or of the wrong type is a typecheck failure, which is the point of the card being a module: a card matched by string prefixes fails silently in every direction, and a key spelled one letter wrong reaches the model as a speech habit rather than as an error.
+
+**`habits`, `greeting` and `signOff` are the model's**: three habits, a greeting and a sign-off, **about fifty tokens in total**. Each habit is a sentence fragment a model can apply to its own wording: a register ("formal, never contracts a word"), a recurring device ("answers a question with a question first"), a verbal tic named rather than quoted. The ceiling is the design — the published comparisons of persona prompts agree that a long character sheet degrades engineering output while a functional identity of a few lines does not — so a card that needs more lines is describing the character, not the voice.
+
+**`habits` is also what the lore pick reads.** The typed decision that chooses the session's character describes each option by its habits, falling back to the game's own line only for a character nobody has carded. So a habit is doing two jobs: telling the model how to sound, and telling the picker who this is to spend a session with.
+
+**The greeting is the one line a card performs rather than describes.** The session-start hook shows it to the person as the welcome, and it is the model's example of a spoken line — how the character says hello, which no reply repeats, since the welcome already has — so it is one or two short sentences in Latin script, spoken words and nothing else, since a stage direction or a mark of emphasis in the example is written into lines the engine then reads aloud, and it is written as the character would say hello — a fresh line in our words that echoes how their own hello line moves (who they name themselves as, what they ask first), never that line reworded closely enough to be recognised.
+
+The welcome puts the greeting straight under the plugin's own lines — the nameplate, the bracketed birthday note and the remarks about the pick and the voice — so the two kinds must not blur. The greeting is **speech, in the first person or addressed to the person at the keyboard, in the present**: "At your service" is a greeting, "Greets warmly" is a description, and "Clorinde is here" is a caption. It also holds nothing the character could not know from where they stand: no date, no birthday, no session or plugin. The birthday is the note's to say, and the character answers about it only when asked, so a greeting that mentions one is wrong on a birthday and wrong every other day.
+
+## The reference
+
+**`reference` is the synthesizer's and never reaches the model** — a character is not told which line their voice is cloned from. It is also **optional, and the ear's alone**: every character's measured reference is one entry of the generated `src/generated/PersonaReferenceMap.ts`, written by the repository's reference selection and never edited by hand, and a card names a line only when someone listened and chose one over it. The plugin reads the card's over the generated one, so deleting the card's restores the measurement.
+
+```ts
+reference: "Clorinde More About Clorinde - 03",
+```
+
+The value is the line's file stem on the community wiki — the title after `VO_` and the dub prefix, before `.ogg` — which is the same in every dub, so one stem serves whichever dub the person set up. The stems a character has are the ones `lines <name>` prints titles for, spelled as the wiki's voice-over page files them; a stem the wiki holds no file under leaves the character silent and the reason in the synthesizer's log, so a card that gains or changes one is checked:
+
+```bash
+pnpm ai:voice-match --check
+```
+
+The full reasoning — how a reference is chosen and what its likeness number is worth — is the [reference selection](https://esposter.com/docs/infra/claude-interface/reference-selection) page's. **The generated values are measured, not heard**; correcting one by ear is a welcome edit, and the card is where that correction goes — never the generated map, which the next run overwrites. A session tempted to re-derive a reference by taste runs the measurement instead.
+
+## The spinner verbs
+
+**`verbs` are the person's and never reach the model**: the hook writes them to the spinner. They cost no tokens, so their ceiling is taste rather than budget. A card carries no tips: the spinner's tips are the character's own lines, every one, read off the game data at runtime, and a tip performed in our words from them is a paraphrase shown beside its original.
+
+- **Verbs** are two to four gerunds in the character's occupation, cased like the built-in ones (`["Duelling", "Judging", "Patrolling"]`). A verb can be hyphenated ("Beetle-fighting") but never a phrase. They are shown behind the base list below, so a card lists what only this character would be doing.
+- **The base verbs** are the `verbs` of the interface language's module under `src/localizations/`: the Teyvat gerunds every character shows before their own. There is no base tip: a character with no lines anywhere yet shows the game's one-line description of them, which is still theirs, under their name.
+
+## Sources
+
+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>
+```
+
+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.
+
+```mermaid
+flowchart TD
+    Queue["uncarded, then unverbed<br/>newest first"]
+    Lines["lines &lt;name&gt;<br/>game data, else the wiki"]
+    Found{Lines found?}
+    Author["Write the card fields<br/>in our words, from the lines"]
+    Thin["Verbs from the description"]
+    Check["typecheck, then today<br/>the shape holds, the queue shrinks"]
+
+    Queue --> Lines --> Found
+    Found -- yes --> Author
+    Found -- no --> Thin --> Author
+    Author --> Check --> Queue
+```
+
+## The one rule
+
+**A card describes how the character speaks, never what the assistant should do.** "Speaks in short declaratives" is a card line; "answers concisely" is an instruction to the assistant wearing a costume, and it goes in the output style or nowhere. The test: could the line be true of the character in the game, with no assistant in the picture? If not, cut it.
+
+This is also why a card carries no field for what the character is _good for_ — "suits a long refactor", "good on a bad day". That is the assistant's job description in the character's clothing, and the lore pick is meant to weigh who someone **is** against the day, not to read a label saying when to pick them.

package/skills/language/SKILL.md

@@ -0,0 +1,14 @@
+---
+name: language
+description: Sets the language every word the plugin writes is in — the card, the spinner's verbs and tips, the status line and each verb's own output — and carries the reply language with it. Given no language, reports what is set and lists the ones the data package answers in.
+argument-hint: [language]
+disable-model-invocation: true
+---
+
+# Language
+
+```bash
+node "${CLAUDE_PLUGIN_ROOT}/scripts/genshin.ts" 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

@@ -0,0 +1,13 @@
+---
+name: mute
+description: Stops replies' spoken lines being read aloud. The pick and the card are unaffected.
+disable-model-invocation: true
+---
+
+# Mute
+
+```bash
+node "${CLAUDE_PLUGIN_ROOT}/scripts/genshin.ts" mute
+```
+
+Relay its lines as written.

package/skills/pin/SKILL.md

@@ -0,0 +1,14 @@
+---
+name: pin
+description: Fixes one character for every session until unpinned, this one from this reply on. The name is matched whole, ignoring case.
+argument-hint: <name>
+disable-model-invocation: true
+---
+
+# Pin
+
+```bash
+node "${CLAUDE_PLUGIN_ROOT}/scripts/genshin.ts" pin $ARGUMENTS
+```
+
+Relay its lines as written, and answer as the card it printed from this reply on.

package/skills/reply/SKILL.md

@@ -0,0 +1,14 @@
+---
+name: reply
+description: Sets the language replies are written in, on its own, for someone who wants the plugin's labels in one language and its prose in another. Given nothing, reports what is set and whether it was set or cascaded from the interface language.
+argument-hint: [language]
+disable-model-invocation: true
+---
+
+# Reply
+
+```bash
+node "${CLAUDE_PLUGIN_ROOT}/scripts/genshin.ts" reply $ARGUMENTS
+```
+
+Relay its lines as written, and write every reply in that language from this one on.

package/skills/roster/SKILL.md

@@ -0,0 +1,13 @@
+---
+name: roster
+description: Every playable character, one line each: name, title, element, region, birthday, the patch that introduced them.
+disable-model-invocation: true
+---
+
+# Roster
+
+```bash
+node "${CLAUDE_PLUGIN_ROOT}/scripts/genshin.ts" roster
+```
+
+Relay its lines as written.

package/skills/setup/SKILL.md

@@ -0,0 +1,13 @@
+---
+name: setup
+description: Writes the status line and the spinner into user settings, the spinner under this session's character's name.
+disable-model-invocation: true
+---
+
+# Setup
+
+```bash
+node "${CLAUDE_PLUGIN_ROOT}/scripts/genshin.ts" setup
+```
+
+Relay its lines as written.

package/skills/status/SKILL.md

@@ -0,0 +1,13 @@
+---
+name: status
+description: Reports every knob the plugin holds at once — who is speaking and by which route, both languages and where each came from, the dub and the device it settled on, whether replies are muted and at what volume, and whether the status line and spinner are the plugin's. Changes nothing.
+disable-model-invocation: true
+---
+
+# Status
+
+```bash
+node "${CLAUDE_PLUGIN_ROOT}/scripts/genshin.ts" status
+```
+
+Relay its lines as written.

package/skills/teardown/SKILL.md

@@ -0,0 +1,13 @@
+---
+name: teardown
+description: Removes exactly what setup and voice wrote and nothing else — the status line and spinner settings, and the voice's runtime, weights, references and language.
+disable-model-invocation: true
+---
+
+# Teardown
+
+```bash
+node "${CLAUDE_PLUGIN_ROOT}/scripts/genshin.ts" teardown
+```
+
+Relay its lines as written.

package/skills/today/SKILL.md

@@ -0,0 +1,13 @@
+---
+name: today
+description: The card of this session's character; from a shell, of the pinned character, else of a fresh pick. Reports a pin that names nobody in the roster; that pin is ignored.
+disable-model-invocation: true
+---
+
+# Today
+
+```bash
+node "${CLAUDE_PLUGIN_ROOT}/scripts/genshin.ts" today
+```
+
+Relay its lines as written.

package/skills/unmute/SKILL.md

@@ -0,0 +1,13 @@
+---
+name: unmute
+description: Lets replies' spoken lines be read aloud again.
+disable-model-invocation: true
+---
+
+# Unmute
+
+```bash
+node "${CLAUDE_PLUGIN_ROOT}/scripts/genshin.ts" unmute
+```
+
+Relay its lines as written.

package/skills/unpin/SKILL.md

@@ -0,0 +1,13 @@
+---
+name: unpin
+description: Removes the pin; the pick decides again from the next session, and for this one from this reply on.
+disable-model-invocation: true
+---
+
+# Unpin
+
+```bash
+node "${CLAUDE_PLUGIN_ROOT}/scripts/genshin.ts" unpin
+```
+
+Relay its lines as written, and answer as the card it printed from this reply on.

package/skills/use/SKILL.md

@@ -0,0 +1,14 @@
+---
+name: use
+description: Speaks as one character for this session alone, from this reply on; other sessions and the next start are untouched. The name is matched whole, ignoring case.
+argument-hint: <name>
+disable-model-invocation: true
+---
+
+# Use
+
+```bash
+node "${CLAUDE_PLUGIN_ROOT}/scripts/genshin.ts" use $ARGUMENTS
+```
+
+Relay its lines as written, and answer as the card it printed from this reply on.

package/skills/voice/SKILL.md

@@ -0,0 +1,14 @@
+---
+name: voice
+description: Sets up spoken replies in the character's own cloned voice, or switches the dub the reference lines are taken from — en, ja, ko or zh — installing the engine's runtime and weights into the plugin's state directory on the first run; with no dub, reports what is installed.
+argument-hint: [en | ja | ko | zh]
+disable-model-invocation: true
+---
+
+# Voice
+
+```bash
+node "${CLAUDE_PLUGIN_ROOT}/scripts/genshin.ts" voice $ARGUMENTS
+```
+
+Relay its lines as written. The first run downloads the engine's runtime and weights — a couple of gigabytes — and prints its progress; it ends by speaking one sentence as this session's character, so the person hears the voice before the first reply does. It also writes the hook that reads each reply's spoken lines into user settings, which the tool reads once per process, so replies are read from the next session.

package/skills/volume/SKILL.md

@@ -0,0 +1,14 @@
+---
+name: volume
+description: Sets how loud replies are spoken, as a whole number from 0 to 100.
+argument-hint: <volume>
+disable-model-invocation: true
+---
+
+# Volume
+
+```bash
+node "${CLAUDE_PLUGIN_ROOT}/scripts/genshin.ts" volume $ARGUMENTS
+```
+
+Relay its lines as written.