genshin-mods 4.3.3 → 4.5.0

package/src/services/diskScan/getDiskScanRefusal.ts

@@ -1,75 +1,5 @@
-import type { CommandRefusal } from "../shell/getShellRefusal";
-
 import { getShellRefusal } from "../shell/getShellRefusal";
-
-// A root in any spelling is a folder whose scan reads the whole disk: the drive's folders, the users' folders and the
-// Home folder by name, once Windows drive letters and backslashes are read as Git Bash's `/c/...` form
-const ROOT_REGEX =
-  /^(?:\/[a-z]?|\/(?:c\/)?Users(?:\/[^/]+)?|\/home(?:\/[^/]+)?|~|\$HOME|\$\{HOME\}|\$USERPROFILE|%USERPROFILE%)$/u;
-
-const SCAN_COMMANDS: ReadonlySet<string> = new Set(["du", "find", "grep", "ls"]);
-
-// Backslashes become slashes, a drive letter becomes its `/c` folder, and a trailing glob and slash go, so "C:\", "/c/",
-// "C:/" and "/c/*" all name "/c": a folder's glob expands to its entries, whose scan reads the whole folder
-const normalizePath = (token: string) => {
-  const slashed = token.replaceAll("\\", "/");
-  const path = /^[A-Za-z]:/u.test(slashed) ? `/${slashed.charAt(0).toLowerCase()}${slashed.slice(2)}` : slashed;
-  return path.replace(/(?<=\/)\*$/u, "").replace(/(?<=.)\/+$/u, "");
-};
-
-const isRoot = (token: string) => ROOT_REGEX.test(normalizePath(token));
-
-// The long form `--recursive`, which getopt also takes as any prefix of it from `--rec` on, since `--re` names two options
-const isRecursiveLongFlag = (token: string) => token.startsWith("--rec") && "recursive".startsWith(token.slice(2));
-
-// A flag group holding the scan's recursive letter, or the long form: grep takes r or R (`-R`, `-rn`, `-lR`), and ls takes
-// The capital R alone, since its lowercase r sorts in reverse
-const GREP_RECURSIVE_FLAG_REGEX = /^-[a-zA-Z]*[rR]/u;
-const LS_RECURSIVE_FLAG_REGEX = /^-[a-zA-Z]*R/u;
-const isRecursiveFlag = (token: string, shortFlagRegex: RegExp) =>
-  shortFlagRegex.test(token) || isRecursiveLongFlag(token);
-
-// A flag that gives grep its pattern as the next argument, or as the rest of the same one
-const SEPARATE_PATTERN_FLAG_REGEX = /^-[a-zA-Z]*[ef]$|^--(?:regexp|file)$/u;
-const ATTACHED_PATTERN_FLAG_REGEX = /^-[a-zA-Z]*[ef].|^--(?:regexp|file)=/u;
-
-// Grep's flags and search paths: a pattern flag's operand is its pattern and never a flag or a path, every argument
-// After a `--` is a positional one, and with no pattern flag the first positional argument is the pattern
-const readGrepArguments = (args: string[]): { flags: string[]; paths: string[] } => {
-  const flags: string[] = [];
-  const positionals: string[] = [];
-  let hasPatternFlag = false;
-  let isPatternOperand = false;
-  let isOptionEnd = false;
-  for (const arg of args)
-    if (isPatternOperand) isPatternOperand = false;
-    else if (isOptionEnd || !arg.startsWith("-")) positionals.push(arg);
-    else if (arg === "--") isOptionEnd = true;
-    else {
-      flags.push(arg);
-      if (SEPARATE_PATTERN_FLAG_REGEX.test(arg)) {
-        hasPatternFlag = true;
-        isPatternOperand = true;
-      } else if (ATTACHED_PATTERN_FLAG_REGEX.test(arg)) hasPatternFlag = true;
-    }
-  return { flags, paths: hasPatternFlag ? positionals : positionals.slice(1) };
-};
-
-// The scan's name when its arguments start it from a root, undefined when they do not
-const getScanRefusal = (name: string, args: string[]): string | undefined => {
-  if (name === "find" || name === "du") return args.some((arg) => isRoot(arg)) ? name : undefined;
-  if (name === "ls")
-    return args.some((arg) => isRecursiveFlag(arg, LS_RECURSIVE_FLAG_REGEX)) && args.some((arg) => isRoot(arg))
-      ? name
-      : undefined;
-  const { flags, paths } = readGrepArguments(args);
-  return flags.some((flag) => isRecursiveFlag(flag, GREP_RECURSIVE_FLAG_REGEX)) && paths.some((path) => isRoot(path))
-    ? name
-    : undefined;
-};
-
-const getScanCommandRefusal: CommandRefusal = (name, args) =>
-  SCAN_COMMANDS.has(name) ? getScanRefusal(name, args) : undefined;
+import { getScanCommandRefusal } from "./getScanCommandRefusal";
 
 // The scan a Bash command runs from a root or a home folder, named by its command, undefined for every other command
 export const getDiskScanRefusal = (command: string): string | undefined =>
@@ -77,7 +7,7 @@ export const getDiskScanRefusal = (command: string): string | undefined =>
 
 // The known homes the refusal names. The mod ships without @esposter/shared, so the product's name is spelled here
 // As the folder it is on the person's disk
-const KNOWN_HOME_LINES: string[] = [
+export const KNOWN_HOME_LINES: string[] = [
   "- the repo, searched with `rg` or `git grep` (both skip node_modules);",
   // oxlint-disable-next-line naming/no-site-name-literal -- A path on the person's disk, which a package shipped without @esposter/shared cannot derive from SITE_NAME
   "- `~/Esposter/genshin-parity`, for game data and captures;",
@@ -85,9 +15,3 @@ const KNOWN_HOME_LINES: string[] = [
   "- a pinned tool (FFmpeg, yt-dlp) through `resolvePinnedTool`;",
   "- a package through `require.resolve` from the package that depends on it.",
 ];
-
-export const getDenyReason = (scanName: string): string =>
-  [
-    `Refused: ${scanName} scans from a root or a home folder, which reads the whole disk for a file whose home is known, and costs minutes of CPU and disk for every agent running. Look where the file lives instead:`,
-    ...KNOWN_HOME_LINES,
-  ].join("\n");

package/src/services/diskScan/getScanCommandRefusal.ts

@@ -0,0 +1,8 @@
+import type { CommandRefusal } from "../../models/CommandRefusal";
+
+import { getScanRefusal } from "./getScanRefusal";
+
+const SCAN_COMMANDS: ReadonlySet<string> = new Set(["du", "find", "grep", "ls"]);
+
+export const getScanCommandRefusal: CommandRefusal = (name, args) =>
+  SCAN_COMMANDS.has(name) ? getScanRefusal(name, args) : undefined;

package/src/services/diskScan/getScanRefusal.ts

@@ -0,0 +1,21 @@
+import { isRecursiveFlag } from "./isRecursiveFlag";
+import { isRoot } from "./isRoot";
+import { readGrepArguments } from "./readGrepArguments";
+
+// A flag group holding the scan's recursive letter, or the long form: grep takes r or R (`-R`, `-rn`, `-lR`), and ls takes
+// The capital R alone, since its lowercase r sorts in reverse
+const GREP_RECURSIVE_FLAG_REGEX = /^-[a-zA-Z]*[rR]/u;
+const LS_RECURSIVE_FLAG_REGEX = /^-[a-zA-Z]*R/u;
+
+// The scan's name when its arguments start it from a root, undefined when they do not
+export const getScanRefusal = (name: string, args: string[]): string | undefined => {
+  if (name === "find" || name === "du") return args.some((arg) => isRoot(arg)) ? name : undefined;
+  if (name === "ls")
+    return args.some((arg) => isRecursiveFlag(arg, LS_RECURSIVE_FLAG_REGEX)) && args.some((arg) => isRoot(arg))
+      ? name
+      : undefined;
+  const { flags, paths } = readGrepArguments(args);
+  return flags.some((flag) => isRecursiveFlag(flag, GREP_RECURSIVE_FLAG_REGEX)) && paths.some((path) => isRoot(path))
+    ? name
+    : undefined;
+};

package/src/services/diskScan/isRecursiveFlag.ts

@@ -0,0 +1,4 @@
+import { isRecursiveLongFlag } from "./isRecursiveLongFlag";
+
+export const isRecursiveFlag = (token: string, shortFlagRegex: RegExp) =>
+  shortFlagRegex.test(token) || isRecursiveLongFlag(token);

package/src/services/diskScan/isRecursiveLongFlag.ts

@@ -0,0 +1,3 @@
+// The long form `--recursive`, which getopt also takes as any prefix of it from `--rec` on, since `--re` names two options
+export const isRecursiveLongFlag = (token: string) =>
+  token.startsWith("--rec") && "recursive".startsWith(token.slice(2));

package/src/services/diskScan/isRoot.ts

@@ -0,0 +1,8 @@
+import { normalizePath } from "./normalizePath";
+
+// A root in any spelling is a folder whose scan reads the whole disk: the drive's folders, the users' folders and the
+// Home folder by name, once Windows drive letters and backslashes are read as Git Bash's `/c/...` form
+const ROOT_REGEX =
+  /^(?:\/[a-z]?|\/(?:c\/)?Users(?:\/[^/]+)?|\/home(?:\/[^/]+)?|~|\$HOME|\$\{HOME\}|\$USERPROFILE|%USERPROFILE%)$/u;
+
+export const isRoot = (token: string) => ROOT_REGEX.test(normalizePath(token));

package/src/services/diskScan/normalizePath.ts

@@ -0,0 +1,7 @@
+// Backslashes become slashes, a drive letter becomes its `/c` folder, and a trailing glob and slash go, so "C:\", "/c/",
+// "C:/" and "/c/*" all name "/c": a folder's glob expands to its entries, whose scan reads the whole folder
+export const normalizePath = (token: string) => {
+  const slashed = token.replaceAll("\\", "/");
+  const path = /^[A-Za-z]:/u.test(slashed) ? `/${slashed.charAt(0).toLowerCase()}${slashed.slice(2)}` : slashed;
+  return path.replace(/(?<=\/)\*$/u, "").replace(/(?<=.)\/+$/u, "");
+};

package/src/services/diskScan/readGrepArguments.ts

@@ -0,0 +1,25 @@
+// A flag that gives grep its pattern as the next argument, or as the rest of the same one
+const SEPARATE_PATTERN_FLAG_REGEX = /^-[a-zA-Z]*[ef]$|^--(?:regexp|file)$/u;
+const ATTACHED_PATTERN_FLAG_REGEX = /^-[a-zA-Z]*[ef].|^--(?:regexp|file)=/u;
+
+// Grep's flags and search paths: a pattern flag's operand is its pattern and never a flag or a path, every argument
+// After a `--` is a positional one, and with no pattern flag the first positional argument is the pattern
+export const readGrepArguments = (args: string[]): { flags: string[]; paths: string[] } => {
+  const flags: string[] = [];
+  const positionals: string[] = [];
+  let hasPatternFlag = false;
+  let isPatternOperand = false;
+  let isOptionEnd = false;
+  for (const arg of args)
+    if (isPatternOperand) isPatternOperand = false;
+    else if (isOptionEnd || !arg.startsWith("-")) positionals.push(arg);
+    else if (arg === "--") isOptionEnd = true;
+    else {
+      flags.push(arg);
+      if (SEPARATE_PATTERN_FLAG_REGEX.test(arg)) {
+        hasPatternFlag = true;
+        isPatternOperand = true;
+      } else if (ATTACHED_PATTERN_FLAG_REGEX.test(arg)) hasPatternFlag = true;
+    }
+  return { flags, paths: hasPatternFlag ? positionals : positionals.slice(1) };
+};

package/src/services/diskScan/registerDiskScan.ts

@@ -1,6 +1,7 @@
 import type { EngineInterface, On } from "claude-code";
 
-import { getDenyReason, getDiskScanRefusal } from "./getDiskScanRefusal";
+import { getDenyReason } from "./getDenyReason";
+import { getDiskScanRefusal } from "./getDiskScanRefusal";
 
 // Any failure lets the command through, as the ward's and the delegation guard's do: a guard that blocked on its own
 // Failure would block every command after it

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,9 @@ import { atom, read, update } from "claude-code";
 
 import type { EnabledMods } from "../../types";
 
+import { ModName } from "../models/ModName";
+import { SinStatusKind } from "../models/SinStatusKind";
+import { TaskStatus } from "../models/TaskStatus";
 import {
   CACHE_WARNING_MS,
   MACHINE_WATCHER_RETRY_MILLISECONDS,
@@ -15,11 +18,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 +47,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 +58,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 +92,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 +101,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 +155,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 +169,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 === ModName.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 +196,7 @@ export const registerLifecycle = (on: On): void => {
         $.command.register({ argumentHint: "[on|off]", description: ModDescriptionMap[name], name }),
       ),
     );
-    watchPulse($);
+    runDetached(() => watchPulse($));
     return next(e);
   });
 
@@ -137,6 +205,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($);
     }
@@ -152,13 +223,16 @@ export const registerLifecycle = (on: On): void => {
     await update($, lookupStreakAtom, () => InitialState.lookupStreak);
     await update($, lastPromptAtom, () => e.text);
     const { tasks } = await read($, commissionAtom);
-    if (tasks.length > 0 && tasks.every(({ status }) => status === "completed")) await closeCommission($);
+    if (tasks.length > 0 && tasks.every(({ status }) => status === TaskStatus.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 +274,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/shell/getDollarSubstitutionBodies.ts

@@ -0,0 +1,25 @@
+// The bodies of a command's `$(…)` substitutions, which run even inside double quotes: each runs to the parenthesis
+// Closing it, past any a quote or a backslash holds, so a body such as `find / -name '(x)'` is read whole. A
+// Substitution inside a body is the body's own, read when the body is
+export const getDollarSubstitutionBodies = (command: string): string[] => {
+  const bodies: string[] = [];
+  let start = command.indexOf("$(");
+  while (start !== -1) {
+    let depth = 1;
+    let quote = "";
+    let index = start + 2;
+    for (; index < command.length && depth > 0; index++) {
+      const character = command[index];
+      if (character === "\\" && quote !== "'") index++;
+      else if (quote !== "") {
+        if (character === quote) quote = "";
+      } else if (character === '"' || character === "'") quote = character;
+      else if (character === "(") depth++;
+      else if (character === ")") depth--;
+    }
+    if (depth > 0) break;
+    bodies.push(command.slice(start + 2, index - 1));
+    start = command.indexOf("$(", index);
+  }
+  return bodies;
+};

package/src/services/shell/getShellRefusal.ts

@@ -1,4 +1,8 @@
+import type { CommandRefusal } from "../../models/CommandRefusal";
+
+import { getDollarSubstitutionBodies } from "./getDollarSubstitutionBodies";
 import { joinDirectory } from "./joinDirectory";
+import { tokenize } from "./tokenize";
 
 // A shell command passed as one argument (`bash -c "…"`) is read again on its own, to this depth at most
 const MAX_NESTING_DEPTH = 3;
@@ -8,46 +12,8 @@ const SEGMENT_REGEX = /(?:"[^"]*"|'[^']*'|[^\n"&'();`|])+/gu;
 // A backtick substitution runs even inside double quotes, so its body is read again on its own
 const BACKTICK_SUBSTITUTION_REGEX = /`(?<body>[^`]*)`/gu;
 const SHELL_FLAG_REGEX = /^-[a-zA-Z]*c$|^eval$/u;
-const TOKEN_REGEX = /"(?<double>[^"]*)"|'(?<single>[^']*)'|(?<bare>\S+)/gu;
 const PATH_SEPARATOR_REGEX = /[/\\]/u;
 
-// The refusal for a command's name, the arguments after it and the folder it runs in from the session's ("" for the
-// Session's own), undefined when the command is not one the guard reads
-export type CommandRefusal<T = string> = (name: string, args: string[], directory: string) => T | undefined;
-
-// A quoted argument keeps its inner spaces, so a shell command passed as one argument is read again on its own
-const tokenize = (segment: string) =>
-  Array.from(
-    segment.matchAll(TOKEN_REGEX),
-    (match) => match.groups?.double ?? match.groups?.single ?? match.groups?.bare ?? "",
-  );
-
-// The bodies of a command's `$(…)` substitutions, which run even inside double quotes: each runs to the parenthesis
-// Closing it, past any a quote or a backslash holds, so a body such as `find / -name '(x)'` is read whole. A
-// Substitution inside a body is the body's own, read when the body is
-const getDollarSubstitutionBodies = (command: string): string[] => {
-  const bodies: string[] = [];
-  let start = command.indexOf("$(");
-  while (start !== -1) {
-    let depth = 1;
-    let quote = "";
-    let index = start + 2;
-    for (; index < command.length && depth > 0; index++) {
-      const character = command[index];
-      if (character === "\\" && quote !== "'") index++;
-      else if (quote !== "") {
-        if (character === quote) quote = "";
-      } else if (character === '"' || character === "'") quote = character;
-      else if (character === "(") depth++;
-      else if (character === ")") depth--;
-    }
-    if (depth > 0) break;
-    bodies.push(command.slice(start + 2, index - 1));
-    start = command.indexOf("$(", index);
-  }
-  return bodies;
-};
-
 // The refusal of the first command in a Bash command that the given reader refuses, undefined when none does. A `cd`
 // Moves every command after it in the line; one to a home folder or back to the last is not followed
 export const getShellRefusal = <T = string>(

package/src/services/shell/tokenize.ts

@@ -0,0 +1,8 @@
+const TOKEN_REGEX = /"(?<double>[^"]*)"|'(?<single>[^']*)'|(?<bare>\S+)/gu;
+
+// A quoted argument keeps its inner spaces, so a shell command passed as one argument is read again on its own
+export const tokenize = (segment: string) =>
+  Array.from(
+    segment.matchAll(TOKEN_REGEX),
+    (match) => match.groups?.double ?? match.groups?.single ?? match.groups?.bare ?? "",
+  );

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" },
+};