genshin-mods 4.3.2 → 4.4.0

package/.claude-plugin/plugin.json

@@ -2,11 +2,19 @@
   "$schema": "https://json.schemastore.org/claude-code-plugin-manifest.json",
   "name": "genshin-mods",
   "displayName": "Genshin Mods",
-  "description": "Six Claude Code mods: five under one band above the prompt, waypoints (the next steps, one press each), resin (cache, context, limits and cost, with warm, compact and a one-click handoff), veil (recording mode), commission (a goal's task list and clock) and ward (a question before editing a file another session just changed), and a delegation guard that nudges a run of lookups toward a haiku agent.",
+  "description": "Six Claude Code mods, each switched by its own command: five under one band above the prompt, waypoints (the next steps, one press each), resin (cache, context, limits and cost, with warm, compact and a one-click handoff), veil (recording mode), commission (a goal's task list and clock), ward (a question before editing a file another session just changed, and a refusal of a git command over the whole index while another session shares the checkout), and pulse (the machine watcher). Two guards run in every session without a command: a delegation guard that nudges a run of lookups toward a haiku agent, and a disk-scan guard that refuses a Bash scan from a root or home folder.",
   "author": { "name": "Esposter", "url": "https://github.com/Esposter" },
   "homepage": "https://github.com/Esposter/Esposter/tree/main/openspec/specs/infra/claude-interface/genshin-mods",
   "repository": "https://github.com/Esposter/Esposter",
   "license": "Apache-2.0",
   "keywords": ["cache", "collision", "genshin", "handoff", "mods", "recording", "tasks"],
-  "types": "./types/index.d.ts"
+  "types": "./types/index.d.ts",
+  "userConfig": {
+    "typesafe_key": {
+      "type": "string",
+      "title": "TypeSafe key",
+      "description": "A TypeSafe API key for sins: with it, each prompt's seven sins are scored by one typed decision and drawn in a pane. The same option as genshin-persona's, stored in the credential store, never in a settings file.",
+      "sensitive": true
+    }
+  }
 }

package/README.md

@@ -7,20 +7,12 @@
 
 A Claude Code plugin of mods: five drawn as one band above the prompt, in the session character's colour (the next steps one press away, what the session is spending with a one-press handoff, recording mode, a goal's task list and clock, and a question before editing a file another session just changed), a delegation guard that refuses any subagent not on haiku and nudges a run of lookups toward a haiku agent, a disk-scan guard that refuses a Bash scan from a root or a home folder, and a whole-index guard that refuses a git command over the whole index while another session shares the checkout.
 
-- **Waypoints** — after each answered turn, up to three next steps the session suggests, each a button that sends it as the next prompt.
-- **Resin** — the prompt cache's time left, the context window, the five-hour and weekly limits and the cost so far, with **Warm**, **Compact** and **Handoff**, a toast before the cache goes cold, and a usage reserve past four-fifths of a limit window, or past half of one spent ahead of an even pace, that has the session clean up on cheap agents, then wind down, until the window resets, refusing a workflow at launch meanwhile.
-- **Veil** — recording mode: emails, amounts, phone numbers and secrets shown as placeholders while the model still reads the real values.
-- **Commission** — a goal meter over the session's task list: the goal, tasks done, the share complete and the minutes since it started.
-- **Ward** — before an edit to a file another session changed in the last half hour, a question: proceed, move to a worktree, or cancel.
-- **Delegation guard** — every subagent launch not on haiku refused, a fork included, and after every third lookup in a row with no decision between them, a note on that call's result that the chain goes to a haiku agent as one bounded question.
-- **Disk-scan guard** — a Bash `find`, `du`, `grep -r` or `ls -R` that starts at `/`, a drive, `~` or a home folder is refused, with the known place to look for the file.
-- **Pulse** — keeps the machine watcher running from any session with the plugin, so its heartbeat and the machine's state keep being written.
-- **Whole-index guard** — while another session edits this checkout, a Bash `git add .`, `git add -A`, `git reset` with no path, `git stash`, `git checkout .` or `git clean` is refused, with the path-scoped form to use instead.
+Design notes live in [the specs](https://github.com/Esposter/Esposter/tree/main/openspec/specs/infra/claude-interface/genshin-mods).
 
 ## Table of Contents
 
 - 🚀 [Getting Started](#getting-started)
-- 📖 [Documentation](#documentation)
+- ⌨️ [Commands](#commands)
 - ⚖️ [License](#license)
 
 ---
@@ -34,6 +26,12 @@ claude plugin marketplace add Esposter/Esposter
 claude plugin install genshin-mods@esposter
 ```
 
+`/sins` scores with [TypeSafe](https://typesafe.ai), so it needs a key: the plugin's `typesafe_key` option, the same option [`genshin-persona`](https://github.com/Esposter/Esposter/tree/main/packages/genshin-persona) has, or the `TYPESAFE_API_KEY` variable when the option is empty:
+
+```bash
+claude plugin install genshin-mods@esposter --config typesafe_key=<key>
+```
+
 A clone of this repository needs neither command: `.agents/settings.json` enables the plugin at project scope once you trust the repository. With [`genshin-persona`](https://github.com/Esposter/Esposter/tree/main/packages/genshin-persona) installed beside it, the band takes the session character's colour; without it, the game's interface gold.
 
 Developing the plugin from a checkout loads the directory itself, with the installed copy disabled so only one of them answers:
@@ -43,35 +41,22 @@ claude plugin disable genshin-mods@esposter
 claude --plugin-dir packages/genshin-mods
 ```
 
-## <a name="documentation">📖 Documentation</a>
-
-We highly recommend you take a look at the [documentation](https://github.com/Esposter/Esposter/tree/main/openspec/specs/infra/claude-interface/genshin-mods) to level up.
-
-### Command reference
+## <a name="commands">⌨️ Commands</a>
 
 Each mod is switched by its own slash command; bare, it flips, and the choice is kept across sessions:
 
 | Command                   | What it does                                                                                                                    |
 | :------------------------ | :------------------------------------------------------------------------------------------------------------------------------ |
-| `/waypoints [on \| off]`  | Suggests the next steps after each answered turn, or stops                                                                      |
-| `/resin [on \| off]`      | Shows the cache, context, limits and cost row and its warning toast                                                             |
-| `/veil [on \| off]`       | Turns recording mode on or off; off by default                                                                                  |
 | `/commission [on \| off]` | Shows the goal meter while a turn works through a task list                                                                     |
 | `/pulse [on \| off]`      | Keeps the machine watcher running, or stops                                                                                     |
+| `/resin [on \| off]`      | Shows the cache, context, limits and cost row and its warning toast                                                             |
+| `/sins [on \| off]`       | Scores each prompt's seven sins with TypeSafe, drawn as bars in a pane; needs the `typesafe_key` option or `TYPESAFE_API_KEY`   |
+| `/veil [on \| off]`       | Turns recording mode on or off; off by default                                                                                  |
 | `/ward [on \| off]`       | Asks before an edit to a file another session just changed, and refuses a whole-index git command while one shares the checkout |
+| `/waypoints [on \| off]`  | Suggests the next steps after each answered turn, or stops                                                                      |
 
 With the band focused (a click or `ctrl+x tab`), `w`, `c` and `h` warm, compact and hand off, `1` to `3` send a waypoint and `g` opens or closes the whole task list.
 
-### Commands
-
-Run from `packages/genshin-mods/`:
-
-```bash
-pnpm test         # vitest watch mode (coverage is run from the repo root)
-pnpm validate     # claude plugin validate: the engine's own reading of the hooks module
-pnpm lint:fix     # auto-fix lint
-```
-
 ## <a name="license">⚖️ License</a>
 
 This project is licensed under the [Apache-2.0 license](https://github.com/Esposter/Esposter/blob/main/LICENSE).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "genshin-mods",
-  "version": "4.3.2",
+  "version": "4.4.0",
   "description": "A Claude Code plugin of mods: five under one band above the prompt (the next steps, the cache and usage with a one-click handoff, recording mode, a goal's task list and a question before editing a file another session just changed) a delegation guard that nudges a run of lookups toward a haiku agent, a disk-scan guard that refuses a Bash scan from a root or a home folder, and a whole-index guard that refuses a git command over the whole index while another session shares the checkout.",
   "keywords": [
     "claude-code",
@@ -36,5 +36,5 @@
     "test": "vitest",
     "validate": "claude plugin validate ."
   },
-  "gitHead": "58d7f270fcb942d6ddf63c32deb29b67ba62f348"
+  "gitHead": "e1a416c4b91da69cc2aa259b50a4d656f204d272"
 }

package/src/models/ModName.ts

@@ -0,0 +1,9 @@
+export enum ModName {
+  Commission = "commission",
+  Pulse = "pulse",
+  Resin = "resin",
+  Sins = "sins",
+  Veil = "veil",
+  Ward = "ward",
+  Waypoints = "waypoints",
+}

package/src/models/SinFigures.ts

@@ -0,0 +1,4 @@
+export interface SinFigures {
+  score: number;
+  spread: number;
+}

package/src/models/SinName.ts

@@ -0,0 +1,12 @@
+export enum SinName {
+  Envy = "envy",
+  Gluttony = "gluttony",
+  Greed = "greed",
+  Lust = "lust",
+  Pride = "pride",
+  Sloth = "sloth",
+  Wrath = "wrath",
+}
+
+// The seven sins, in the order the pane draws them. Each is one `score` question Jev answers about a prompt
+export const SIN_NAMES: readonly SinName[] = Object.values(SinName);

package/src/models/SinPosterior.ts

@@ -0,0 +1,4 @@
+export interface SinPosterior {
+  alpha: number;
+  beta: number;
+}

package/src/models/SinScore.ts

@@ -0,0 +1,7 @@
+import type { SinFigures } from "./SinFigures";
+import type { SinName } from "./SinName";
+
+export interface SinScore extends SinFigures {
+  name: SinName;
+  trend: number[];
+}

package/src/models/SinStatusKind.ts

@@ -0,0 +1,8 @@
+// What the sins mod last found: its scores when the call answered, or why it could not score the last prompt
+export enum SinStatusKind {
+  Answered = "answered",
+  Failed = "failed",
+  NodeTooOld = "node-too-old",
+  NoKey = "no-key",
+  Unchecked = "unchecked",
+}

package/src/models/SinsResult.ts

@@ -0,0 +1,6 @@
+// What the plugin's node script answers: the seven answers, or why none were recorded
+import type { SinStatusKind } from "./SinStatusKind";
+
+export type SinsResult =
+  | { answers: Record<string, { confidence: number; score: number }>; result: SinStatusKind.Answered }
+  | { reason?: string; result: SinStatusKind.Failed | SinStatusKind.NodeTooOld | SinStatusKind.NoKey };

package/src/models/TaskCall.ts

@@ -3,12 +3,6 @@ import type { TaskTool } from "./TaskTool";
 
 // One task tool call with what its result says, in the shapes the engine's own tools declare
 export type TaskCall =
-  | {
-      id: string;
-      // oxlint-disable-next-line literal-union/no-string-literal-union -- The engine's own TaskUpdate statuses
-      status?: "deleted" | CommissionTask["status"];
-      subject?: string;
-      tool: TaskTool.TaskUpdate;
-    }
+  | { id: string; status?: "deleted" | CommissionTask["status"]; subject?: string; tool: TaskTool.TaskUpdate }
   | { id: string; subject: string; tool: TaskTool.TaskCreate }
   | { todos: { content: string; status: CommissionTask["status"] }[]; tool: TaskTool.TodoWrite };

package/src/models/TaskStatus.ts

@@ -0,0 +1,6 @@
+// The engine's own task statuses, as its task tools spell them
+export enum TaskStatus {
+  Completed = "completed",
+  InProgress = "in_progress",
+  Pending = "pending",
+}

package/src/models/UsageWindow.ts

@@ -1,10 +1,8 @@
 export interface UsageWindow {
   // The window's length, which its reset time is counted back from
   durationMs: number;
-  // The usage line the window's maintenance tier starts at
+  // The usage line the window's maintenance line starts at
   maintenancePercentage: number;
   // The window's name as the reserve's note spells it
   name: string;
-  // The usage line the window's wind-down starts at
-  windDownPercentage: number;
 }

package/src/register.ts

@@ -6,17 +6,21 @@ import { registerDelegation } from "./services/delegation/registerDelegation";
 import { registerDiskScan } from "./services/diskScan/registerDiskScan";
 import { registerLifecycle } from "./services/registerLifecycle";
 import { registerReserveGate } from "./services/resin/registerReserveGate";
+import { registerSins } from "./services/sins/registerSins";
 import { registerVeil } from "./services/veil/registerVeil";
 import { registerWard } from "./services/ward/registerWard";
 import { registerWholeIndex } from "./services/ward/registerWholeIndex";
 
-export const register: Register = (on) => {
-  registerBand(on);
+export const register: Register = (on, options) => {
+  // The plugin's typesafe_key option, empty when it is not set: the sins readers fall back to the TYPESAFE_API_KEY variable
+  const typeSafeKey = typeof options.typesafe_key === "string" ? options.typesafe_key : "";
+  registerBand(on, typeSafeKey);
   registerCommission(on);
   registerDelegation(on);
   registerDiskScan(on);
-  registerLifecycle(on);
+  registerLifecycle(on, typeSafeKey);
   registerReserveGate(on);
+  registerSins(on, typeSafeKey);
   registerVeil(on);
   registerWard(on);
   registerWholeIndex(on);

package/src/services/InitialState.ts

@@ -1,16 +1,21 @@
 import type { PluginState } from "claude-code";
 
+import { SinStatusKind } from "../models/SinStatusKind";
+
 // Every state value's initial, read by each file's atoms: the engine traces a state reference only to an atom made in
 // The file that uses it, so each file makes its own and this is the one place their initials are written
 export const InitialState: PluginState["genshin-mods"] = {
   commission: { goal: "", openedAt: 0, tasks: [] },
-  enabledMods: { commission: true, pulse: true, resin: true, veil: false, ward: true, waypoints: true },
+  enabledMods: { commission: true, pulse: true, resin: true, sins: false, veil: false, ward: true, waypoints: true },
   isCommissionExpanded: false,
   isHandingOff: false,
   lastCacheRequestAt: 0,
   lastPrompt: "",
   lookupStreak: 0,
   now: 0,
-  reserveWindow: { isAheadOfPace: false, isWindDown: false, name: "", percentage: 0, resetsAt: "" },
+  reserveWindow: { isAheadOfPace: false, name: "", percentage: 0, resetsAt: "" },
+  sinHistory: {},
+  sinSession: 0,
+  sinStatus: SinStatusKind.Unchecked,
   waypoints: [],
 };

package/src/services/ModDescriptionMap.ts

@@ -1,13 +1,17 @@
 import type { EnabledMods } from "../../types";
 
+import { ModName } from "../models/ModName";
+
 // Each mod's command, `/<name> [on|off]`, as the menu describes it
 export const ModDescriptionMap: Record<keyof EnabledMods, string> = {
-  commission: "Show a goal's task list, how far it is and how long it has run.",
-  pulse: "Keep the machine watcher running.",
-  resin: "Show the cache, context, limits and cost, with warm, compact and handoff.",
-  veil: "Recording mode: show emails, amounts, phone numbers and secrets as placeholders.",
-  ward: "Ask before editing a file another session changed in the last half hour, and refuse a whole-index git command while one shares the checkout.",
-  waypoints: "Suggest the next steps after each answer, one press each.",
+  [ModName.Commission]: "Show a goal's task list, how far it is and how long it has run.",
+  [ModName.Pulse]: "Keep the machine watcher running.",
+  [ModName.Resin]: "Show the cache, context, limits and cost, with warm, compact and handoff.",
+  [ModName.Sins]: "Score each prompt's seven sins with TypeSafe, drawn as bars in a pane. Needs a TypeSafe key.",
+  [ModName.Veil]: "Recording mode: show emails, amounts, phone numbers and secrets as placeholders.",
+  [ModName.Ward]:
+    "Ask before editing a file another session changed in the last half hour, and refuse a whole-index git command while one shares the checkout.",
+  [ModName.Waypoints]: "Suggest the next steps after each answer, one press each.",
 };
 
 export const ModNames = Object.keys(ModDescriptionMap) as (keyof EnabledMods)[];

package/src/services/band/registerBand.ts

@@ -4,9 +4,16 @@ import { atom, read, update } from "claude-code";
 
 import type { EnabledMods } from "../../../types";
 
+import { TaskStatus } from "../../models/TaskStatus";
 import { ACCENT_COLOR, HANDOFF_QUESTION, MAX_SHOWN_TASKS, WARM_QUESTION } from "../constants";
 import { InitialState } from "../InitialState";
 import { getResinFigures } from "../resin/getResinFigures";
+import { SINS_PANE_ID } from "../sins/constants";
+import { getSinScores } from "../sins/getSinScores";
+import { readIsLightTheme } from "../sins/readIsLightTheme";
+import { readSinStatus } from "../sins/readSinStatus";
+import { SinColorMap } from "../sins/SinColorMap";
+import { SinStatusTextMap } from "../sins/SinStatusTextMap";
 import { getCommissionSummary } from "./getCommissionSummary";
 
 // The plugin's one band, a row per mod with something to say. `$` is followed only into functions in the file that
@@ -23,6 +30,7 @@ const lastCacheRequestAtAtom = atom(
   InitialState.lastCacheRequestAt,
 );
 const nowAtom = atom({ key: "now", plugin: "genshin-mods" } as const, InitialState.now);
+const sinHistoryAtom = atom({ key: "sinHistory", plugin: "genshin-mods" } as const, InitialState.sinHistory);
 const waypointsAtom = atom({ key: "waypoints", plugin: "genshin-mods" } as const, InitialState.waypoints);
 
 // The engine's press slot takes no promise; every action here resolves each of its outcomes itself
@@ -31,7 +39,7 @@ const press = (action: () => Promise<unknown>) => () => {
   action();
 };
 
-const StatusMarkMap = { completed: "✓", in_progress: "▸", pending: "·" } as const;
+const StatusMarkMap = { [TaskStatus.Completed]: "✓", [TaskStatus.InProgress]: "▸", [TaskStatus.Pending]: "·" } as const;
 
 // A fork re-sends the conversation's prefix, which renews the cache from the moment it is sent, and adds no row to the
 // Transcript
@@ -125,7 +133,7 @@ const drawCommissionRow = async (
   const isExpanded = await read($, isCommissionExpandedAtom);
   const shownTasks = isExpanded
     ? commission.tasks.slice(0, MAX_SHOWN_TASKS)
-    : commission.tasks.filter(({ status }) => status === "in_progress");
+    : commission.tasks.filter(({ status }) => status === TaskStatus.InProgress);
   const { Box, Button, Text } = $.ui.resolve(e);
   return Box({
     children: [
@@ -146,7 +154,7 @@ const drawCommissionRow = async (
       ...shownTasks.map(({ status, subject }) =>
         Text({
           children: `  ${StatusMarkMap[status]} ${subject}`,
-          dimColor: status !== "in_progress",
+          dimColor: status !== TaskStatus.InProgress,
           wrap: "truncate-end",
         }),
       ),
@@ -189,9 +197,47 @@ const drawWaypointsRow = async (
   });
 };
 
+// The sins as one line, each in its colour, with the pane's own button; the pane holds the bars and the trends
+const drawSinsRow = async (
+  $: EngineInterface,
+  e: RenderInput<"AbovePrompt">,
+  enabledMods: EnabledMods,
+  accent: string,
+  typeSafeKey: string,
+): Promise<RenderElement | undefined> => {
+  if (!enabledMods.sins) return undefined;
+
+  const scores = getSinScores(await read($, sinHistoryAtom));
+  const isLight = await readIsLightTheme($);
+  const summary = SinStatusTextMap[await readSinStatus($, typeSafeKey)];
+  const { Box, Button, Text } = $.ui.resolve(e);
+  return Box({
+    children: [
+      Text({ bold: true, children: "Sins  ", color: accent }),
+      ...(summary ? [Text({ children: `${summary}  `, dimColor: true })] : []),
+      ...(scores.length === 0 && !summary ? [Text({ children: "no prompt scored yet  ", dimColor: true })] : []),
+      ...scores.map(({ name, score }) =>
+        Text({
+          children: `${name} ${Math.round(score * 100)}%  `,
+          color: SinColorMap[name][isLight ? "light" : "dark"],
+        }),
+      ),
+      Button({
+        hotkey: "p",
+        key: "sins-panel",
+        label: "Panel",
+        onPress: press(() => $.ui.open({ id: SINS_PANE_ID, title: "Seven sins" })),
+        plain: true,
+      }),
+    ],
+    flexDirection: "row",
+    flexWrap: "wrap",
+  });
+};
+
 // The veil's marker first, so a recording never runs with it off unnoticed, and the engine's own band whenever no
 // Mod has anything to say
-export const registerBand = (on: On): void => {
+export const registerBand = (on: On, typeSafeKey: string): void => {
   on("ui.render", { component: "AbovePrompt" }, async ($, e, next) => {
     if (e.props.hasSurvey) return next(e);
 
@@ -202,6 +248,7 @@ export const registerBand = (on: On): void => {
         drawResinRow($, e, enabledMods, accent),
         drawCommissionRow($, e, enabledMods, accent),
         drawWaypointsRow($, e, enabledMods, accent),
+        drawSinsRow($, e, enabledMods, accent, typeSafeKey),
       ])
     ).filter((row) => row !== undefined);
     if (rows.length === 0 && !enabledMods.veil) return next(e);

package/src/services/constants.ts

@@ -5,11 +5,9 @@ export const CACHE_LIFETIME_MS: number = Temporal.Duration.from({ hours: 1 }).to
 export const CACHE_LOW_MS: number = Temporal.Duration.from({ minutes: 10 }).total("milliseconds");
 export const CACHE_WARNING_MS: number = Temporal.Duration.from({ minutes: 5 }).total("milliseconds");
 export const USAGE_WARNING_PERCENTAGE = 80;
-// The usage lines each window's two tiers start at: the maintenance tier, then the wind-down
+// The usage line each window's maintenance line starts at
 export const FIVE_HOUR_MAINTENANCE_PERCENTAGE = 80;
-export const FIVE_HOUR_WIND_DOWN_PERCENTAGE = 90;
 export const WEEKLY_MAINTENANCE_PERCENTAGE = 80;
-export const WEEKLY_WIND_DOWN_PERCENTAGE = 90;
 // A window under this share is never read for its pace, since an early reading projects wildly
 export const PACE_FLOOR_PERCENTAGE = 50;
 // Each window's length, which its reset time is counted back from
@@ -42,12 +40,9 @@ export const VEIL_SECTION_ID = "genshin-mods-veil";
 export const VEIL_SYSTEM_SECTION =
   "Recording mode is on: the screen is being recorded or shared. Never write an email address, a phone number, a money amount, an API key, a token or a password in a reply; write a placeholder such as [email], [phone], [amount] or [secret] instead, even when asked for the value. Tool calls still use the real values.";
 export const RESERVE_SECTION_ID = "genshin-mods-reserve";
-// The wind-down's section ends on this instruction, the same for every window so only the window and its reset time vary
-export const RESERVE_INSTRUCTION =
-  "Until it resets, start no new agent or workflow that writes code or designs; have each running one commit what builds and end on a handoff spec; commit and push the work in hand; write every open item down with what it takes to resume it cold (its paths, what is done, the calls made, the next step); clean up idle servers, shells and monitors; keep only long-running compute going.";
-// The maintenance tier's section ends on this instruction: the window's rest goes on cleanup a haiku agent can do cold
+// The reserve's section ends on this instruction: the window's rest goes on cleanup a haiku agent can do cold
 export const MAINTENANCE_INSTRUCTION =
-  "Until it resets, start no new feature, design or proposal; spend the rest of the window on haiku agents for cleanup: fix the findings of a code review of this window's own recent commits, drain an open sweep ledger, bring the docs and skills in line with the code changed this window, fix CI's typecheck and lint reds, and land the refactors, simplifications and optimisations the compute queue's runs surfaced; write a finding that needs judgement down as a follow-up (the follow-ups plugin's capture skill) rather than deciding it on haiku; keep the compute queue's runners going.";
+  "Until it resets, spend the rest of the window on haiku agents for cleanup: fix the findings of a code review of this window's own recent commits, drain an open sweep ledger, bring the docs and skills in line with the code changed this window, fix CI's typecheck and lint reds, and land the refactors, simplifications and optimisations the compute queue's runs surfaced; write a finding that needs judgement down as a follow-up (the follow-ups plugin's capture skill) rather than deciding it on haiku; keep the compute queue's runners going.";
 // The tools that look something up, the tools that change files, and the shells whose command decides which it is
 export const LOOKUP_TOOLS: readonly string[] = ["Glob", "Grep", "Read", "WebFetch"];
 export const RESET_TOOLS: readonly string[] = ["Agent", "Edit", "NotebookEdit", "Write"];

package/src/services/readHome.ts

@@ -0,0 +1,7 @@
+import type { EngineInterface } from "claude-code";
+
+// The person's home folder, read from the engine's environment: HOME where it is set, else the Windows profile folder
+// oxlint-disable-next-line func-style -- A declaration, not an arrow: the hooks module's bundle follows an imported helper that takes `$` only into a function declaration
+export async function readHome($: EngineInterface): Promise<string> {
+  return (await $.env.get("HOME")) ?? (await $.env.get("USERPROFILE")) ?? "";
+}

package/src/services/registerLifecycle.ts

@@ -4,6 +4,7 @@ import { atom, read, update } from "claude-code";
 
 import type { EnabledMods } from "../../types";
 
+import { SinStatusKind } from "../models/SinStatusKind";
 import {
   CACHE_WARNING_MS,
   MACHINE_WATCHER_RETRY_MILLISECONDS,
@@ -15,11 +16,19 @@ import {
 } from "./constants";
 import { InitialState } from "./InitialState";
 import { ModDescriptionMap, ModNames } from "./ModDescriptionMap";
+import { readHome } from "./readHome";
 import { getCacheRemainingMs } from "./resin/getCacheRemainingMs";
 import { getCacheWarningDelayMs } from "./resin/getCacheWarningDelayMs";
 import { getReserveSummary } from "./resin/getReserveSummary";
 import { getReserveWindow } from "./resin/getReserveWindow";
 import { reserveText } from "./resin/reserveText";
+import { appendSinEvidence } from "./sins/appendSinEvidence";
+import { SINS_API_URL, SINS_TIMEOUT_MS } from "./sins/constants";
+import { getSinQuestions } from "./sins/getSinQuestions";
+import { parseSinsResult } from "./sins/parseSinsResult";
+import { readTypeSafeKey } from "./sins/readTypeSafeKey";
+import { SINS_SCRIPT } from "./sins/sinsScript";
+import { veilText } from "./veil/veilText";
 import { parseWaypoints } from "./waypoints/parseWaypoints";
 
 const commissionAtom = atom({ key: "commission", plugin: "genshin-mods" } as const, InitialState.commission);
@@ -36,6 +45,9 @@ const lastCacheRequestAtAtom = atom(
 const lookupStreakAtom = atom({ key: "lookupStreak", plugin: "genshin-mods" } as const, InitialState.lookupStreak);
 const nowAtom = atom({ key: "now", plugin: "genshin-mods" } as const, InitialState.now);
 const reserveWindowAtom = atom({ key: "reserveWindow", plugin: "genshin-mods" } as const, InitialState.reserveWindow);
+const sinHistoryAtom = atom({ key: "sinHistory", plugin: "genshin-mods" } as const, InitialState.sinHistory);
+const sinSessionAtom = atom({ key: "sinSession", plugin: "genshin-mods" } as const, InitialState.sinSession);
+const sinStatusAtom = atom({ key: "sinStatus", plugin: "genshin-mods" } as const, InitialState.sinStatus);
 const waypointsAtom = atom({ key: "waypoints", plugin: "genshin-mods" } as const, InitialState.waypoints);
 
 // The events a plugin may hook once with no matcher, each hooked here for every mod, with the commands that switch
@@ -44,6 +56,13 @@ const waypointsAtom = atom({ key: "waypoints", plugin: "genshin-mods" } as const
 let warnedLastCacheRequestAt = 0;
 let isTurnRunning = false;
 
+// The engine's timer and hook slots take no promise, so an action run from one floats. Every action run through here
+// Resolves each of its outcomes rather than rejecting, which is what lets the floating stand
+const runDetached = (action: () => Promise<void>): void => {
+  // oxlint-disable-next-line typescript/no-floating-promises -- The engine's timer and hook slots take no promise, and every action run through here resolves each of its outcomes
+  action();
+};
+
 // The cache goes cold at a known instant, so its warning is one timer armed for that instant at each turn's end, from the
 // Request that last read or wrote the cache, rather than a check on a clock. The timer warns once for that request, and
 // Stands down while a turn runs, since that turn's end arms it again. A timer left from an earlier turn finds the cache
@@ -71,8 +90,7 @@ const armCacheWarning = async ($: EngineInterface) => {
   if (delayMs === undefined) return;
 
   $.clock.after(delayMs, () => {
-    // oxlint-disable-next-line typescript/no-floating-promises -- The engine's timer slot takes no promise, and every call in the warning resolves
-    warnCache($);
+    runDetached(() => warnCache($));
   });
 };
 
@@ -81,6 +99,50 @@ const suggestWaypoints = async ($: EngineInterface) => {
   if (answer.isAnswered) await update($, waypointsAtom, () => parseWaypoints(answer.text));
 };
 
+// The sins are scored beside the prompt's turn, never in front of it: the call and the evidence log run in the plugin's
+// Node script, and a run that fails, or a machine that cannot open the log, records nothing and says why in the band
+const scoreSins = async ($: EngineInterface, text: string, typeSafeKey: string) => {
+  if (!(await read($, enabledModsAtom)).sins) return;
+
+  const key = await readTypeSafeKey($, typeSafeKey);
+  if (!key) {
+    await update($, sinStatusAtom, () => SinStatusKind.NoKey);
+    return;
+  }
+
+  const session = (await read($, sinSessionAtom)) || (await $.clock.now());
+  await update($, sinSessionAtom, () => session);
+  const home = await readHome($);
+  const [outcome] = await Promise.allSettled([
+    $.process.run(["node", "--input-type=module", "-e", SINS_SCRIPT], {
+      stdin: JSON.stringify({
+        apiUrl: SINS_API_URL,
+        key,
+        questions: getSinQuestions(),
+        session,
+        state: veilText(text),
+        storePath: `${home}/.claude/genshin-mods/sins.sqlite`,
+      }),
+      timeoutMs: SINS_TIMEOUT_MS,
+    }),
+  ]);
+  const result =
+    outcome.status === "fulfilled" && outcome.value.exitCode === 0
+      ? parseSinsResult(outcome.value.stdout)
+      : { result: SinStatusKind.Failed as const };
+
+  // A `/clear` or a resume during the run has reset the session, and a switch turned off has turned the mod off, so this
+  // Run's answers belong to nothing shown
+  const sessionNow = await read($, sinSessionAtom);
+  const { sins } = await read($, enabledModsAtom);
+  if (sessionNow !== session || !sins) return;
+
+  if (result.result === SinStatusKind.Answered)
+    await update($, sinHistoryAtom, (history) => appendSinEvidence(history, result.answers));
+
+  await update($, sinStatusAtom, () => result.result);
+};
+
 // Keeps the machine watcher running as this session's child. The watcher writes the machine's state, holds its lock and
 // Pushes its heartbeat, so its output is read only to keep the child's pipe drained. A watcher exits at once while another
 // Session's holds the machine's lock, so each exit starts the watcher again after a wait, and the session that outlives the
@@ -91,14 +153,12 @@ const watchPulse = async ($: EngineInterface) => {
   const cwd = await $.session.cwd();
   if (!(await $.fs.exists(`${cwd}/${MACHINE_WATCHER_SCRIPT}`))) return;
 
-  // oxlint-disable-next-line no-underscore-dangle -- The chunks are discarded, and the binding is only the loop's syntax
-  for await (const _chunk of $.process.spawn({ argv: ["pnpm", "ai:machine:watch"], cwd })) {
+  for await (const _ of $.process.spawn({ argv: ["pnpm", "ai:machine:watch"], cwd })) {
     // The watcher's output is discarded, since nothing in the session reads it
   }
 
   $.clock.after(MACHINE_WATCHER_RETRY_MILLISECONDS, () => {
-    // oxlint-disable-next-line typescript/no-floating-promises -- The engine's timer slot takes no promise, and the watcher's run settles as its process exits
-    watchPulse($);
+    runDetached(() => watchPulse($));
   });
 };
 
@@ -107,15 +167,21 @@ const closeCommission = async ($: EngineInterface) => {
   await update($, isCommissionExpandedAtom, () => InitialState.isCommissionExpanded);
 };
 
-export const registerLifecycle = (on: On): void => {
+export const registerLifecycle = (on: On, typeSafeKey: string): void => {
   // The bare command flips a mod and an argument sets it, kept in the store so it holds for every later session
   for (const name of ModNames)
     on("command.run", { command: name }, async ($, e) => {
       const argument = e.args.trim().toLowerCase();
-      const enabledMods = await update($, enabledModsAtom, (value) => ({
-        ...value,
-        [name]: argument ? argument === "on" : !value[name],
-      }));
+      const current = await read($, enabledModsAtom);
+      const isNext = argument ? argument === "on" : !current[name];
+      // Sins scores only with a TypeSafe key, so turning it on without one is refused and its value is left as it was
+      if (name === "sins" && isNext) {
+        const key = await readTypeSafeKey($, typeSafeKey);
+        if (!key)
+          return { text: "Sins needs a TypeSafe key: set the typesafe_key option, or TYPESAFE_API_KEY, first." };
+      }
+
+      const enabledMods = await update($, enabledModsAtom, (value) => ({ ...value, [name]: isNext }));
       await $.store.set(enabledModsAtom.ref.key, enabledMods);
       return { text: `${name} is ${enabledMods[name] ? "on" : "off"}.` };
     });
@@ -128,7 +194,7 @@ export const registerLifecycle = (on: On): void => {
         $.command.register({ argumentHint: "[on|off]", description: ModDescriptionMap[name], name }),
       ),
     );
-    watchPulse($);
+    runDetached(() => watchPulse($));
     return next(e);
   });
 
@@ -137,6 +203,9 @@ export const registerLifecycle = (on: On): void => {
   on("session.end", async ($, e, next) => {
     if (e.reason === "clear" || e.reason === "resume") {
       await update($, lastCacheRequestAtAtom, () => InitialState.lastCacheRequestAt);
+      await update($, sinHistoryAtom, () => InitialState.sinHistory);
+      await update($, sinSessionAtom, () => InitialState.sinSession);
+      await update($, sinStatusAtom, () => InitialState.sinStatus);
       await update($, waypointsAtom, () => InitialState.waypoints);
       await closeCommission($);
     }
@@ -153,12 +222,15 @@ export const registerLifecycle = (on: On): void => {
     await update($, lastPromptAtom, () => e.text);
     const { tasks } = await read($, commissionAtom);
     if (tasks.length > 0 && tasks.every(({ status }) => status === "completed")) await closeCommission($);
+    $.clock.after(0, () => {
+      runDetached(() => scoreSins($, e.text, typeSafeKey));
+    });
     return next(e);
   });
 
   // While the veil is on, the model is told to write placeholders too, so a reply never holds a value to hide. While a
-  // Usage reserve holds and the resin mod is on, the model is told what the reserve's tier asks until the window resets,
-  // Which it may have done since the last measurement
+  // Usage reserve holds and the resin mod is on, the model is told what the reserve asks until the window resets, which
+  // It may have done since the last measurement
   on("prompt.compose", async ($, e, next) => {
     const result = await next(e);
     const { resin, veil } = await read($, enabledModsAtom);
@@ -200,25 +272,19 @@ export const registerLifecycle = (on: On): void => {
     await armCacheWarning($);
     if (e.reason === "answer" && (await read($, enabledModsAtom)).waypoints)
       $.clock.after(0, () => {
-        // oxlint-disable-next-line typescript/no-floating-promises -- The engine's timer slot takes no promise, and a fork resolves every outcome rather than rejecting
-        suggestWaypoints($);
+        runDetached(() => suggestWaypoints($));
       });
     return result;
   });
 
-  // The reserve is read off each measurement: it starts at the first window past a tier's line and lifts at the
-  // Measurement a window's reset raises, which finds none. The toast names the window once, as the reserve starts, and
-  // Again as its maintenance tier is raised to the wind-down
+  // The reserve is read off each measurement: it starts at the first window past its line and lifts at the measurement a
+  // Window's reset raises, which finds none. The toast names the window once, as the reserve starts
   on("session.measure", async ($, e, next) => {
     const now = await $.clock.now();
     const reserveWindow = getReserveWindow(e.rateLimits, now);
     const previousReserveWindow = await read($, reserveWindowAtom);
     await update($, reserveWindowAtom, () => reserveWindow ?? InitialState.reserveWindow);
-    if (
-      reserveWindow &&
-      (!previousReserveWindow.name || (reserveWindow.isWindDown && !previousReserveWindow.isWindDown)) &&
-      (await read($, enabledModsAtom)).resin
-    )
+    if (reserveWindow && !previousReserveWindow.name && (await read($, enabledModsAtom)).resin)
       $.ui.toast(`${getReserveSummary(reserveWindow)}.`);
 
     return next(e);

package/src/services/resin/RateLimitKindUsageWindowMap.ts

@@ -2,26 +2,18 @@ import type { UsageWindow } from "../../models/UsageWindow";
 
 import {
   FIVE_HOUR_MAINTENANCE_PERCENTAGE,
-  FIVE_HOUR_WIND_DOWN_PERCENTAGE,
   FIVE_HOUR_WINDOW_MS,
   WEEKLY_MAINTENANCE_PERCENTAGE,
-  WEEKLY_WIND_DOWN_PERCENTAGE,
   WEEKLY_WINDOW_MS,
 } from "../constants";
 
 // The rate-limit windows a reserve is read off, five-hour before weekly, so the five-hour one is the one named when both
-// Have passed a line of the same tier
+// Have passed their line
 export const RateLimitKindUsageWindowMap: Record<string, UsageWindow> = {
   five_hour: {
     durationMs: FIVE_HOUR_WINDOW_MS,
     maintenancePercentage: FIVE_HOUR_MAINTENANCE_PERCENTAGE,
     name: "five-hour",
-    windDownPercentage: FIVE_HOUR_WIND_DOWN_PERCENTAGE,
-  },
-  seven_day: {
-    durationMs: WEEKLY_WINDOW_MS,
-    maintenancePercentage: WEEKLY_MAINTENANCE_PERCENTAGE,
-    name: "weekly",
-    windDownPercentage: WEEKLY_WIND_DOWN_PERCENTAGE,
   },
+  seven_day: { durationMs: WEEKLY_WINDOW_MS, maintenancePercentage: WEEKLY_MAINTENANCE_PERCENTAGE, name: "weekly" },
 };

package/src/services/resin/formatResetsAt.ts

@@ -1,3 +1,3 @@
-// The reset time as the reader's own clock spells it, such as `Oct 8, 2026, 5:00 PM`
+// The reset time as the reader's own clock spells it, such as a short month, day, year and time
 export const formatResetsAt = (resetsAt: string): string =>
   Temporal.Instant.from(resetsAt).toLocaleString("en", { dateStyle: "medium", timeStyle: "short" });

package/src/services/resin/getReserveSummary.ts

@@ -2,7 +2,7 @@ import type { ReserveWindow } from "../../../types";
 
 import { formatResetsAt } from "./formatResetsAt";
 
-// The sentence a reserve opens with, naming its tier, window, the usage line that window has passed and its reset time,
-// Which the system section and the toast both say
-export const getReserveSummary = ({ isAheadOfPace, isWindDown, name, percentage, resetsAt }: ReserveWindow): string =>
-  `${isWindDown ? "Usage reserve" : "Usage maintenance"}: the ${name} usage window has passed ${percentage}%${isAheadOfPace ? " ahead of an even pace" : ""} and resets at ${formatResetsAt(resetsAt)}`;
+// The sentence a reserve opens with, naming its window, the usage line that window has passed and its reset time, which
+// The system section and the toast both say
+export const getReserveSummary = ({ isAheadOfPace, name, percentage, resetsAt }: ReserveWindow): string =>
+  `Usage maintenance: the ${name} usage window has passed ${percentage}%${isAheadOfPace ? " ahead of an even pace" : ""} and resets at ${formatResetsAt(resetsAt)}`;

package/src/services/resin/getReserveWindow.ts

@@ -5,28 +5,23 @@ import type { ReserveWindow } from "../../../types";
 import { PACE_FLOOR_PERCENTAGE } from "../constants";
 import { RateLimitKindUsageWindowMap } from "./RateLimitKindUsageWindowMap";
 
-// Each window a reserve is read off, five-hour before weekly, so the five-hour one is the one named when both have
-// Passed a line of the same tier. A window is read once past its maintenance line, or once half of its allowance is
-// Spent ahead of an even pace, the share of its length that has elapsed; the wind-down line is read as well. A window
-// The engine gives no reset time for is skipped, since the reserve is named by that time and lifts at it
+// Each window a reserve is read off, five-hour before weekly, so the five-hour one is the one named when both qualify. A
+// Window is read once past its maintenance line, or once half of its allowance is spent ahead of an even pace, the share
+// Of its length that has elapsed. A window the engine gives no reset time for is skipped, since the reserve is named by
+// That time and lifts at it
 export const getReserveWindow = (rateLimits: SessionRateLimit[], now: number): ReserveWindow | undefined => {
   const reserveWindows: ReserveWindow[] = [];
-  for (const [kind, { durationMs, maintenancePercentage, name, windDownPercentage }] of Object.entries(
-    RateLimitKindUsageWindowMap,
-  )) {
+  for (const [kind, { durationMs, maintenancePercentage, name }] of Object.entries(RateLimitKindUsageWindowMap)) {
     const rateLimit = rateLimits.find((limit) => limit.kind === kind);
     if (rateLimit?.resetsAt === undefined) continue;
-    const isWindDown = rateLimit.percentUsed >= windDownPercentage;
     const isPastMaintenance = rateLimit.percentUsed >= maintenancePercentage;
     const elapsedPercentage = 100 * (1 - (Date.parse(rateLimit.resetsAt) - now) / durationMs);
     const isAheadOfPace =
       !isPastMaintenance && rateLimit.percentUsed >= PACE_FLOOR_PERCENTAGE && rateLimit.percentUsed > elapsedPercentage;
     if (!isPastMaintenance && !isAheadOfPace) continue;
-    let percentage = PACE_FLOOR_PERCENTAGE;
-    if (isWindDown) percentage = windDownPercentage;
-    else if (isPastMaintenance) percentage = maintenancePercentage;
-    reserveWindows.push({ isAheadOfPace, isWindDown, name, percentage, resetsAt: rateLimit.resetsAt });
+    const percentage = isPastMaintenance ? maintenancePercentage : PACE_FLOOR_PERCENTAGE;
+    reserveWindows.push({ isAheadOfPace, name, percentage, resetsAt: rateLimit.resetsAt });
   }
 
-  return reserveWindows.find(({ isWindDown }) => isWindDown) ?? reserveWindows[0];
+  return reserveWindows[0];
 };

package/src/services/resin/reserveText.ts

@@ -1,9 +1,9 @@
 import type { ReserveWindow } from "../../../types";
 
-import { MAINTENANCE_INSTRUCTION, RESERVE_INSTRUCTION } from "../constants";
+import { MAINTENANCE_INSTRUCTION } from "../constants";
 import { getReserveSummary } from "./getReserveSummary";
 
-// The system section the reserve adds: its summary and the instruction of its tier are the only parts that vary, so the
-// Text holds still for as long as the tier does
+// The system section the reserve adds: the summary is the only part that varies, with the window it names and the line
+// That window has passed, so the text holds still while neither changes
 export const reserveText = (reserveWindow: ReserveWindow): string =>
-  `${getReserveSummary(reserveWindow)}. ${reserveWindow.isWindDown ? RESERVE_INSTRUCTION : MAINTENANCE_INSTRUCTION}`;
+  `${getReserveSummary(reserveWindow)}. ${MAINTENANCE_INSTRUCTION}`;

package/src/services/sins/SinColorMap.ts

@@ -0,0 +1,12 @@
+import { SinName } from "../../models/SinName";
+
+// One fixed slot of the dataviz reference palette per sin, so a sin keeps its colour as its score moves
+export const SinColorMap: Record<SinName, { dark: string; light: string }> = {
+  [SinName.Envy]: { dark: "#c98500", light: "#eda100" },
+  [SinName.Gluttony]: { dark: "#008300", light: "#008300" },
+  [SinName.Greed]: { dark: "#d95926", light: "#eb6834" },
+  [SinName.Lust]: { dark: "#d55181", light: "#e87ba4" },
+  [SinName.Pride]: { dark: "#3987e5", light: "#2a78d6" },
+  [SinName.Sloth]: { dark: "#9085e9", light: "#6250d6" },
+  [SinName.Wrath]: { dark: "#199e70", light: "#1baf7a" },
+};

package/src/services/sins/SinStatusTextMap.ts

@@ -0,0 +1,10 @@
+import type { SinStatus } from "../../../types";
+
+import { SinStatusKind } from "../../models/SinStatusKind";
+
+// Why the band and the pane say so instead of fresh scores, for the statuses that have a reason to say
+export const SinStatusTextMap: Partial<Record<SinStatus, string>> = {
+  [SinStatusKind.Failed]: "Last prompt not scored",
+  [SinStatusKind.NodeTooOld]: "Needs Node 22.13 or later on 22, or 23.4 or later on 23",
+  [SinStatusKind.NoKey]: "Needs a TypeSafe key",
+};

package/src/services/sins/appendSinEvidence.ts

@@ -0,0 +1,18 @@
+import type { SinsResult } from "../../models/SinsResult";
+import type { SinStatusKind } from "../../models/SinStatusKind";
+
+import { SIN_NAMES } from "../../models/SinName";
+import { SIN_HISTORY_LENGTH, SIN_TOP_LEVEL } from "./constants";
+
+// Each sin's evidence gains this prompt's score as a share of the top level, clamped to [0, 1], and the oldest values fall
+// Away past the history's length
+export const appendSinEvidence = (
+  history: Record<string, number[]>,
+  answers: Extract<SinsResult, { result: SinStatusKind.Answered }>["answers"],
+): Record<string, number[]> =>
+  Object.fromEntries(
+    SIN_NAMES.map((name) => {
+      const evidence = Math.min(1, Math.max(0, (answers[name]?.score ?? 0) / SIN_TOP_LEVEL));
+      return [name, [...(history[name] ?? []), evidence].slice(-SIN_HISTORY_LENGTH)];
+    }),
+  );

package/src/services/sins/constants.ts

@@ -0,0 +1,33 @@
+// The five levels every question grades on, from none to extreme, so the sins are comparable with one another
+export const SIN_CRITERIA = [
+  "Absent: the prompt shows none of it",
+  "Slight: a trace of it in passing",
+  "Moderate: it shapes part of the prompt",
+  "Strong: it shapes most of the prompt",
+  "Extreme: it is the whole prompt",
+] as const;
+
+// The top level the score reads, so a score divides by it to lie between none and extreme
+export const SIN_TOP_LEVEL: number = SIN_CRITERIA.length - 1;
+
+// The half-life in prompts: a sin's score moves about halfway toward a new pattern within this many prompts
+export const SIN_HALF_LIFE_PROMPTS = 30;
+
+// Applied to the old counts on each prompt, so each count halves every half-life
+export const SIN_DISCOUNT: number = 2 ** (-1 / SIN_HALF_LIFE_PROMPTS);
+
+// One pseudo-count of each outcome, so a sin with no evidence reads as an even half
+export const SIN_PRIOR = 1;
+
+// The evidence kept per sin: past this the discount has taken the rest, under a tenth of a percent
+export const SIN_HISTORY_LENGTH = 300;
+
+// The bar's width in cells, the solid run to the score and the tinted run to the score plus its spread
+export const SIN_BAR_WIDTH = 24;
+
+export const SINS_PANE_ID = "sins";
+
+// The node script's whole run, its one request included; a run past this is killed and reads as failed
+export const SINS_TIMEOUT_MS = 60_000;
+
+export const SINS_API_URL = "https://api.typesafe.ai/v1/systemone";

package/src/services/sins/getBarCells.ts

@@ -0,0 +1,8 @@
+import type { SinFigures } from "../../models/SinFigures";
+
+// The solid run reaches the score, and the tinted run the score plus its spread, both in cells of the bar's width
+export const getBarCells = ({ score, spread }: SinFigures, width: number): { solid: number; tinted: number } => {
+  const solid = Math.round(score * width);
+  const reach = Math.round(Math.min(1, score + spread) * width);
+  return { solid, tinted: Math.max(0, reach - solid) };
+};

package/src/services/sins/getPosteriorTrail.ts

@@ -0,0 +1,21 @@
+import type { SinPosterior } from "../../models/SinPosterior";
+
+import { SIN_DISCOUNT, SIN_PRIOR } from "./constants";
+
+// Each evidence value is replayed in order, the counts discounted before it is added, so the trail is the posterior
+// After each prompt and its last entry is the posterior now
+export const getPosteriorTrail = (evidences: number[]): SinPosterior[] => {
+  let posterior: SinPosterior = { alpha: SIN_PRIOR, beta: SIN_PRIOR };
+  return evidences.map((evidence) => {
+    posterior = {
+      alpha: SIN_DISCOUNT * posterior.alpha + evidence,
+      beta: SIN_DISCOUNT * posterior.beta + (1 - evidence),
+    };
+    return posterior;
+  });
+};
+
+// The posterior now is the trail's last entry, and a sin with no evidence reads as the prior: an even half with the spread
+// Of one count of each outcome
+export const getPosterior = (trail: SinPosterior[]): SinPosterior =>
+  trail.at(-1) ?? { alpha: SIN_PRIOR, beta: SIN_PRIOR };

package/src/services/sins/getScoreAndSpread.ts

@@ -0,0 +1,8 @@
+import type { SinFigures } from "../../models/SinFigures";
+import type { SinPosterior } from "../../models/SinPosterior";
+
+// The score is the posterior mean and the spread its standard deviation, from the Beta's own variance
+export const getScoreAndSpread = ({ alpha, beta }: SinPosterior): SinFigures => {
+  const total = alpha + beta;
+  return { score: alpha / total, spread: Math.sqrt((alpha * beta) / (total * total * (total + 1))) };
+};

package/src/services/sins/getSinQuestions.ts

@@ -0,0 +1,28 @@
+import { SIN_NAMES, SinName } from "../../models/SinName";
+import { SIN_CRITERIA } from "./constants";
+
+// The question each sin asks Jev about a prompt, held beside the one call that asks them all
+const SinQuestionMap = {
+  [SinName.Envy]:
+    'How far does the prompt measure against another tool, person or project, as in "the other tool", "like theirs" or "why doesn\'t ours do what X does"?',
+  [SinName.Gluttony]: "How heavy is the prompt, as in a large pasted share of text or a whole file or log pasted in?",
+  [SinName.Greed]:
+    'How far does the prompt ask for more than one request holds, as in "and also", "while you\'re at it", "everything" or several tasks at once?',
+  [SinName.Lust]:
+    'How far does the prompt crave the new over the finished, as in "rewrite", "from scratch", "redesign" or "a new approach"?',
+  [SinName.Pride]:
+    'How far does the prompt assert certainty and wave off checks, as in "obviously", "definitely", "no need to test" or "trust me"?',
+  [SinName.Sloth]:
+    'How far is effort handed off without a steer, as in "idk", "whatever", "you decide", "figure it out" or a one-word prompt?',
+  [SinName.Wrath]:
+    'How heated is the prompt\'s register, as in runs of punctuation, words in capitals, "again", "still broken" or "why won\'t"?',
+} as const satisfies Record<SinName, string>;
+
+// The seven `score` questions one call answers, keyed by sin name, each graded on the same five levels
+export const getSinQuestions = (): Record<
+  string,
+  { criteria: typeof SIN_CRITERIA; instructions: string; type: "score" }
+> =>
+  Object.fromEntries(
+    SIN_NAMES.map((name) => [name, { criteria: SIN_CRITERIA, instructions: SinQuestionMap[name], type: "score" }]),
+  );

package/src/services/sins/getSinScores.ts

@@ -0,0 +1,17 @@
+import type { SinScore } from "../../models/SinScore";
+
+import { SIN_NAMES } from "../../models/SinName";
+import { getPosterior, getPosteriorTrail } from "./getPosteriorTrail";
+import { getScoreAndSpread } from "./getScoreAndSpread";
+import { getTrend } from "./getTrend";
+
+// The sins the person can read, in the pane's order: one with no evidence is left out rather than shown as a zero
+export const getSinScores = (history: Record<string, number[]>): SinScore[] =>
+  SIN_NAMES.flatMap((name) => {
+    const evidences = history[name] ?? [];
+    if (evidences.length === 0) return [];
+
+    const trail = getPosteriorTrail(evidences);
+    const figures = getScoreAndSpread(getPosterior(trail));
+    return [{ name, ...figures, trend: getTrend(trail) }];
+  });

package/src/services/sins/getTrend.ts

@@ -0,0 +1,13 @@
+import type { SinPosterior } from "../../models/SinPosterior";
+
+import { SIN_HALF_LIFE_PROMPTS } from "./constants";
+
+const TREND_GLYPHS = "▁▂▃▄▅▆▇█";
+
+// The score after each of the last half-life's prompts, from the trail the score reads, so it is the score's own curve
+export const getTrend = (trail: SinPosterior[]): number[] =>
+  trail.slice(-SIN_HALF_LIFE_PROMPTS).map(({ alpha, beta }) => alpha / (alpha + beta));
+
+// One glyph per point, its height the point's share of the tallest glyph
+export const getTrendGlyphs = (trend: number[]): string =>
+  trend.map((score) => TREND_GLYPHS.charAt(Math.round(score * (TREND_GLYPHS.length - 1)))).join("");

package/src/services/sins/parseSinsResult.ts

@@ -0,0 +1,5 @@
+import type { SinsResult } from "../../models/SinsResult";
+
+// The node script writes one JSON result when it exits cleanly, so a run that exited otherwise never reaches this
+// oxlint-disable-next-line no-restricted-properties -- packages/genshin-mods/package.json has no @esposter/shared dependency, so jsonDateParse is not importable here, and SinsResult (src/models/SinsResult.ts) holds no Date a revival would produce
+export const parseSinsResult = (stdout: string): SinsResult => JSON.parse(stdout) as SinsResult;

package/src/services/sins/pickTypeSafeKey.ts

@@ -0,0 +1,4 @@
+// The key sins scores with: the plugin's own option when it is set, else the variable. A blank option is no key, so the
+// Variable answers, and `||` is what makes it so, since `??` would keep a blank option over a variable that holds one
+export const pickTypeSafeKey = (typeSafeKey: string, variableKey: string | undefined): string =>
+  typeSafeKey || variableKey || "";

package/src/services/sins/readIsLightTheme.ts

@@ -0,0 +1,8 @@
+import type { EngineInterface } from "claude-code";
+
+// The engine's theme row names a light theme with "light" in it, and any other theme reads as dark
+// oxlint-disable-next-line func-style -- A declaration, not an arrow: the hooks module's bundle follows an imported helper that takes `$` only into a function declaration
+export async function readIsLightTheme($: EngineInterface): Promise<boolean> {
+  const theme = (await $.config.list()).find(({ key }) => key === "theme");
+  return String(theme?.value ?? "").includes("light");
+}

package/src/services/sins/readSinStatus.ts

@@ -0,0 +1,20 @@
+import type { EngineInterface } from "claude-code";
+
+import { atom, read } from "claude-code";
+
+import type { SinStatus } from "../../../types";
+
+import { SinStatusKind } from "../../models/SinStatusKind";
+import { InitialState } from "../InitialState";
+import { readTypeSafeKey } from "./readTypeSafeKey";
+
+const sinStatusAtom = atom({ key: "sinStatus", plugin: "genshin-mods" } as const, InitialState.sinStatus);
+
+// The status as the band and the pane draw it: a key removed since the last prompt is said so at each draw, before the next
+// Prompt would say it, and the stored status stands otherwise
+// oxlint-disable-next-line func-style -- A declaration, not an arrow: the hooks module's bundle follows an imported helper that takes `$` into a function declaration
+export async function readSinStatus($: EngineInterface, typeSafeKey: string): Promise<SinStatus> {
+  if (!(await readTypeSafeKey($, typeSafeKey))) return SinStatusKind.NoKey;
+
+  return read($, sinStatusAtom);
+}

package/src/services/sins/readTypeSafeKey.ts

@@ -0,0 +1,10 @@
+import type { EngineInterface } from "claude-code";
+
+import { pickTypeSafeKey } from "./pickTypeSafeKey";
+
+// The key sins scores with: the plugin's option, else the TYPESAFE_API_KEY variable, the two places Genshin-persona reads
+// Its key from, so one key set the same way serves both plugins
+// oxlint-disable-next-line func-style -- A declaration, not an arrow: the hooks module's bundle follows an imported helper that takes `$` into a function declaration
+export async function readTypeSafeKey($: EngineInterface, typeSafeKey: string): Promise<string> {
+  return pickTypeSafeKey(typeSafeKey, await $.env.get("TYPESAFE_API_KEY"));
+}

package/src/services/sins/registerSins.ts

@@ -0,0 +1,56 @@
+import type { On } from "claude-code";
+
+import { atom, read } from "claude-code";
+
+import { InitialState } from "../InitialState";
+import { SIN_BAR_WIDTH, SINS_PANE_ID } from "./constants";
+import { getBarCells } from "./getBarCells";
+import { getSinScores } from "./getSinScores";
+import { getTrendGlyphs } from "./getTrend";
+import { readIsLightTheme } from "./readIsLightTheme";
+import { readSinStatus } from "./readSinStatus";
+import { SinColorMap } from "./SinColorMap";
+import { SinStatusTextMap } from "./SinStatusTextMap";
+
+const enabledModsAtom = atom({ key: "enabledMods", plugin: "genshin-mods" } as const, InitialState.enabledMods);
+const sinHistoryAtom = atom({ key: "sinHistory", plugin: "genshin-mods" } as const, InitialState.sinHistory);
+
+// The seven sins in full: one bar per measured sin in the same order every time, its spread as the tinted tail, and its
+// Last thirty prompts as a trend. It is drawn from the state alone, so a reload redraws it as it was, and it says so
+// Rather than drawing stale bars once the switch is off
+export const registerSins = (on: On, typeSafeKey: string): void => {
+  on("ui.render", { component: "Pane", requestId: SINS_PANE_ID }, async ($, e) => {
+    const { Box, Text } = $.ui.resolve(e);
+    if (!(await read($, enabledModsAtom)).sins)
+      return Box({
+        children: [Text({ children: "Sins is off: turn it on with /sins on.", dimColor: true })],
+        flexDirection: "column",
+      });
+
+    const scores = getSinScores(await read($, sinHistoryAtom));
+    const isLight = await readIsLightTheme($);
+    const statusText = SinStatusTextMap[await readSinStatus($, typeSafeKey)];
+    return Box({
+      children: [
+        Text({ bold: true, children: "Seven sins" }),
+        ...(scores.length === 0 ? [Text({ children: "No prompt scored yet.", dimColor: true })] : []),
+        ...scores.map(({ name, score, spread, trend }) => {
+          const color = SinColorMap[name][isLight ? "light" : "dark"];
+          const { solid, tinted } = getBarCells({ score, spread }, SIN_BAR_WIDTH);
+          const bar = "█".repeat(solid) + "▒".repeat(tinted) + " ".repeat(SIN_BAR_WIDTH - solid - tinted);
+          return Box({
+            children: [
+              Text({ children: name.padEnd(9), color }),
+              Text({ children: bar, color }),
+              Text({ children: `${Math.round(score * 100)}% ±${Math.round(spread * 100)}`.padEnd(12) }),
+              Text({ children: getTrendGlyphs(trend), color }),
+            ],
+            flexDirection: "row",
+          });
+        }),
+        ...(statusText ? [Text({ children: statusText, dimColor: true })] : []),
+      ],
+      flexDirection: "column",
+    });
+  });
+};

package/src/services/sins/sinsScript.ts

@@ -0,0 +1,47 @@
+import { SinStatusKind } from "../../models/SinStatusKind";
+
+// The plugin's node script, run as `node --input-type=module -e` with its request on stdin: the one network call and the
+// Evidence log run here, since the hooks module has no Node. It is a string because a plugin reaches none of its own
+// Files from inside the module, and it writes exactly one JSON result, so a run that exits otherwise reads as failed
+// oxlint-disable-next-line typescript/no-inferrable-types -- isolatedDeclarations asks for the type of an exported template that interpolates, and this rule would refuse that annotation
+export const SINS_SCRIPT: string = `
+import { mkdirSync } from "node:fs";
+import { dirname } from "node:path";
+
+let input = "";
+for await (const chunk of process.stdin) input += chunk;
+const { apiUrl, key, questions, session, state, storePath } = JSON.parse(input);
+const finish = (result) => process.stdout.write(JSON.stringify(result));
+const sqlite = process.getBuiltinModule?.("node:sqlite");
+
+if (!key) finish({ result: "${SinStatusKind.NoKey}" });
+else if (!sqlite) finish({ result: "${SinStatusKind.NodeTooOld}" });
+else {
+  const response = await fetch(apiUrl, {
+    body: JSON.stringify({ model: "jev-latest", questions, state }),
+    headers: { Authorization: "Bearer " + key, "Content-Type": "application/json" },
+    method: "POST",
+  });
+  const answers = response.ok ? (await response.json()).answers || {} : {};
+  const names = Object.keys(questions);
+  const isAnswered = names.every(
+    (name) => typeof answers[name]?.score === "number" && typeof answers[name]?.confidence === "number",
+  );
+  if (!isAnswered) finish({ reason: response.ok ? "unanswered" : "HTTP " + response.status, result: "${SinStatusKind.Failed}" });
+  else {
+    mkdirSync(dirname(storePath), { recursive: true });
+    const database = new sqlite.DatabaseSync(storePath);
+    try {
+      database.exec("PRAGMA busy_timeout = 5000");
+      database.exec(
+        "CREATE TABLE IF NOT EXISTS evidence (id INTEGER PRIMARY KEY, session INTEGER NOT NULL, answers TEXT NOT NULL, recorded_at INTEGER NOT NULL)",
+      );
+      const picked = Object.fromEntries(names.map((name) => [name, { confidence: answers[name].confidence, score: answers[name].score }]));
+      database.prepare("INSERT INTO evidence (session, answers, recorded_at) VALUES (?, ?, ?)").run(session, JSON.stringify(picked), Date.now());
+      finish({ answers: picked, result: "${SinStatusKind.Answered}" });
+    } finally {
+      database.close();
+    }
+  }
+}
+`;

package/src/services/ward/readRecords.ts

@@ -5,5 +5,7 @@ import type { WardRecord } from "../../../types";
 import { parseRecords } from "./parseRecords";
 
 // The records as the file holds them, none when it does not yet exist
-export const readRecords = async ($: EngineInterface, path: string): Promise<Record<string, WardRecord>> =>
-  (await $.fs.exists(path)) ? parseRecords(await $.fs.read(path)) : {};
+// oxlint-disable-next-line func-style -- A declaration, not an arrow: the hooks module's bundle follows an imported helper that takes `$` only into a function declaration
+export async function readRecords($: EngineInterface, path: string): Promise<Record<string, WardRecord>> {
+  return (await $.fs.exists(path)) ? parseRecords(await $.fs.read(path)) : {};
+}

package/src/services/ward/resolveRecordsPath.ts

@@ -1,7 +1,10 @@
 import type { EngineInterface } from "claude-code";
 
+import { readHome } from "../readHome";
 import { getRecordsPath } from "./getRecordsPath";
 
 // The records file under the person's home folder, the home read from the engine's environment lookup
-export const resolveRecordsPath = async ($: EngineInterface): Promise<string> =>
-  getRecordsPath((await $.env.get("HOME")) ?? (await $.env.get("USERPROFILE")) ?? "");
+// oxlint-disable-next-line func-style -- A declaration, not an arrow: the hooks module's bundle follows an imported helper that takes `$` only into a function declaration
+export async function resolveRecordsPath($: EngineInterface): Promise<string> {
+  return getRecordsPath(await readHome($));
+}

package/types/index.d.ts

@@ -8,7 +8,6 @@ export interface Commission {
 
 export interface CommissionTask {
   id: string;
-  // oxlint-disable-next-line literal-union/no-string-literal-union -- The engine's own task statuses, as its task tools spell them
   status: "completed" | "in_progress" | "pending";
   subject: string;
 }
@@ -18,22 +17,25 @@ export interface EnabledMods {
   commission: boolean;
   pulse: boolean;
   resin: boolean;
+  sins: boolean;
   veil: boolean;
   ward: boolean;
   waypoints: boolean;
 }
 
-// The rate-limit window past a usage line, named as its section spells it, the line it has passed, whether that line is
-// The wind-down rather than the maintenance tier, whether the tier was entered by spending ahead of an even pace rather
-// Than by the window's maintenance line, and when it resets; `""` in the name is the absent reserve
+// The rate-limit window past a usage line, named as its section spells it, the line it has passed, whether the reserve
+// Was entered by spending ahead of an even pace rather than by the window's maintenance line, and when it resets; `""`
+// In the name is the absent reserve
 export interface ReserveWindow {
   isAheadOfPace: boolean;
-  isWindDown: boolean;
   name: string;
   percentage: number;
   resetsAt: string;
 }
 
+// What the sins mod last found: its scores when the call answered, or why it could not score the last prompt
+export type SinStatus = "answered" | "failed" | "no-key" | "node-too-old" | "unchecked";
+
 export interface WardRecord {
   editedAt: number;
   sessionId: string;
@@ -51,6 +53,10 @@ declare module "claude-code" {
       lookupStreak: number;
       now: number;
       reserveWindow: ReserveWindow;
+      // Keyed by sin name, the last evidence values of each sin in order
+      sinHistory: Record<string, number[]>;
+      sinSession: number;
+      sinStatus: SinStatus;
       waypoints: string[];
     };
   }