ashlr-plugin 1.36.4

package/hooks/sessionstart-brief.ts

@@ -0,0 +1,140 @@
+#!/usr/bin/env bun
+/**
+ * sessionstart-brief.ts — SessionStart hook that injects the active
+ * ashlr-brief level's ruleset into the session's additionalContext.
+ *
+ * Reads, in order of precedence:
+ *   1. <repo-root>/.ashlr/brief.json   — project-level (Pro-enforced)
+ *   2. ~/.ashlr/brief.json             — user-level
+ *
+ * Active levels: "lite" | "standard" | "concise"
+ * Inactive level: "off" (or missing file) — emits no additionalContext.
+ *
+ * Hook contract (SessionStart):
+ *   stdout → { hookSpecificOutput: { hookEventName: "SessionStart",
+ *                                    additionalContext?: string } }
+ *
+ * Design rules:
+ *   - Never throw — passes through silently on any error.
+ *   - The additionalContext is short (<500 bytes) so it doesn't bloat
+ *     every session that has brief enabled.
+ *   - Always exits 0.
+ */
+
+import { existsSync, readFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+
+import { noteHookError } from "./_hook-errors";
+
+interface BriefConfig {
+  level?: "off" | "lite" | "standard" | "concise";
+  source?: "user" | "project";
+  setAt?: string;
+  writtenBy?: string;
+}
+
+interface HookOutput {
+  hookSpecificOutput: {
+    hookEventName: "SessionStart";
+    additionalContext?: string;
+  };
+}
+
+function safeReadJson(path: string): BriefConfig | null {
+  if (!existsSync(path)) return null;
+  try {
+    return JSON.parse(readFileSync(path, "utf-8")) as BriefConfig;
+  } catch (e) {
+    noteHookError("sessionstart-brief", `parse:${path}`, e);
+    return null;
+  }
+}
+
+/** Find the repo root by walking up from cwd looking for .git or package.json. */
+function findRepoRoot(start: string): string | null {
+  let cur = start;
+  for (let i = 0; i < 10; i++) {
+    if (existsSync(join(cur, ".git")) || existsSync(join(cur, "package.json"))) return cur;
+    const parent = join(cur, "..");
+    if (parent === cur) return null;
+    cur = parent;
+  }
+  return null;
+}
+
+function home(): string {
+  return process.env.HOME ?? homedir();
+}
+
+/** Resolve the active level: project file wins over user file when present. */
+export function resolveActiveLevel(opts?: { homeDir?: string; cwd?: string }): {
+  level: "off" | "lite" | "standard" | "concise";
+  source: "user" | "project" | "none";
+} {
+  const h = opts?.homeDir ?? home();
+  const cwd = opts?.cwd ?? process.cwd();
+
+  // 1. Project file (when in a repo)
+  const repoRoot = findRepoRoot(cwd);
+  if (repoRoot) {
+    const projectCfg = safeReadJson(join(repoRoot, ".ashlr", "brief.json"));
+    if (projectCfg && projectCfg.level && projectCfg.level !== "off") {
+      return { level: projectCfg.level, source: "project" };
+    }
+  }
+
+  // 2. User file
+  const userCfg = safeReadJson(join(h, ".ashlr", "brief.json"));
+  if (userCfg && userCfg.level && userCfg.level !== "off") {
+    return { level: userCfg.level, source: "user" };
+  }
+
+  // 3. Eco-mode fallback — when ASHLR_ECO=1 and no explicit brief level, default
+  //    to "standard". This is the integration point with /ashlr-eco-mode.
+  if (process.env["ASHLR_ECO"] === "1" && (!userCfg || userCfg.level == null || userCfg.level === "off")) {
+    return { level: "standard", source: "user" };
+  }
+
+  return { level: "off", source: "none" };
+}
+
+const RULESETS: Record<"lite" | "standard" | "concise", string> = {
+  lite:
+`[ashlr-brief: lite] Trim filler from prose. Drop "just", "really", "basically", "actually", "simply", "in order to" (use "to"), "due to the fact that" (use "because"). Drop self-narration ("Let me look at...", "I'll now..."). Keep: full grammar, articles, complete sentences, all explanations the user asked for, code blocks, error messages, destructive-action confirmations.`,
+  standard:
+`[ashlr-brief: standard] Drop filler AND padding. Cut transition phrases ("Now that we have X, let's...", "As you can see"), restating-the-question preambles, and "Here's what I did:" lists when the diff already shows it. Replace verbose constructions with short ones. Keep: complete sentences, articles, code blocks untouched, errors verbatim, destructive-action confirmations in full grammar.`,
+  concise:
+`[ashlr-brief: concise] Drop filler, padding, and most articles. Sentence fragments OK when meaning is clear. Arrow notation for causality ("X → Y"). Common abbreviations OK in prose only (db, auth, cfg, req, res, fn, ctx). NEVER abbreviate identifiers, file paths, function names, or render error messages compressed. Keep: code blocks untouched, destructive-action confirmations in full grammar, security findings in full grammar, multi-step migrations in full grammar.`,
+};
+
+const COMMON_RULES =
+`Auto-clarity exceptions (always restore full grammar): destructive actions (rm -rf, git reset --hard, force-push, DROP TABLE, deleting branches), security findings (credentials, secrets, vulnerabilities), multi-step migrations, error messages and stack traces, code blocks and diffs, file:line citations.`;
+
+export function buildAdditionalContext(level: "off" | "lite" | "standard" | "concise", source: "user" | "project" | "none"): string {
+  if (level === "off") return "";
+  const ruleset = RULESETS[level];
+  const sourceLabel = source === "project" ? "project-level (.ashlr/brief.json)" : "user-level (~/.ashlr/brief.json)";
+  return `${ruleset}\n\n${COMMON_RULES}\n\nActive source: ${sourceLabel}. Toggle via /ashlr-brief off.`;
+}
+
+async function main(): Promise<void> {
+  try {
+    const { level, source } = resolveActiveLevel();
+    const out: HookOutput = {
+      hookSpecificOutput: {
+        hookEventName: "SessionStart",
+        ...(level !== "off" ? { additionalContext: buildAdditionalContext(level, source) } : {}),
+      },
+    };
+    process.stdout.write(JSON.stringify(out));
+  } catch (e) {
+    noteHookError("sessionstart-brief", "main", e);
+    // Pass-through on any error.
+    process.stdout.write(JSON.stringify({ hookSpecificOutput: { hookEventName: "SessionStart" } }));
+  }
+}
+
+if (import.meta.main) {
+  void main();
+}

package/hooks/sessionstart-cost-refactor.ts

@@ -0,0 +1,95 @@
+#!/usr/bin/env bun
+/**
+ * sessionstart-cost-refactor.ts — SessionStart hook for the ashlr-cost-refactor skill.
+ *
+ * Injects the ashlr-cost-refactor ruleset as additionalContext when
+ * ~/.ashlr/cost-refactor.json { "enabled": true } (or project-level .ashlr/cost-refactor.json).
+ *
+ * Contract: never throws, always exits 0.
+ */
+
+import { existsSync, readFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+
+import { noteHookError } from "./_hook-errors";
+
+interface SkillConfig {
+  enabled?: boolean;
+}
+
+interface HookOutput {
+  hookSpecificOutput: {
+    hookEventName: "SessionStart";
+    additionalContext?: string;
+  };
+}
+
+const SKILL_KEY = "cost-refactor";
+
+const RULESET = `[ashlr-cost-refactor] Token-efficient refactoring discipline active.
+1. Diff first: run ashlr__diff or ashlr__diff_semantic before editing anything.
+2. Use ashlr__edit_structural for symbol/file renames (finds all refs in one pass).
+3. Find all refs with ashlr__grep, then apply all changes to each file in a single ashlr__multi_edit call.
+4. No re-reads between edits in a sequence — ashlr__edit/multi_edit diffs confirm each change.
+5. Verify with ashlr__bash (typecheck/tests), not Read.
+6. One ashlr__genome_propose at the end summarizing the full refactor.`;
+
+function safeReadJson(path: string): SkillConfig | null {
+  if (!existsSync(path)) return null;
+  try {
+    return JSON.parse(readFileSync(path, "utf-8")) as SkillConfig;
+  } catch (e) {
+    noteHookError(`sessionstart-${SKILL_KEY}`, `parse:${path}`, e);
+    return null;
+  }
+}
+
+function findRepoRoot(start: string): string | null {
+  let cur = start;
+  for (let i = 0; i < 10; i++) {
+    if (existsSync(join(cur, ".git")) || existsSync(join(cur, "package.json"))) return cur;
+    const parent = join(cur, "..");
+    if (parent === cur) return null;
+    cur = parent;
+  }
+  return null;
+}
+
+export function isEnabled(opts?: { homeDir?: string; cwd?: string }): boolean {
+  const h = opts?.homeDir ?? (process.env.HOME ?? homedir());
+  const cwd = opts?.cwd ?? process.cwd();
+
+  const repoRoot = findRepoRoot(cwd);
+  if (repoRoot) {
+    const cfg = safeReadJson(join(repoRoot, ".ashlr", `${SKILL_KEY}.json`));
+    if (cfg !== null) return cfg.enabled === true;
+  }
+
+  const userCfg = safeReadJson(join(h, ".ashlr", `${SKILL_KEY}.json`));
+  return userCfg?.enabled === true;
+}
+
+export function buildAdditionalContext(): string {
+  return RULESET;
+}
+
+async function main(): Promise<void> {
+  try {
+    const enabled = isEnabled();
+    const out: HookOutput = {
+      hookSpecificOutput: {
+        hookEventName: "SessionStart",
+        ...(enabled ? { additionalContext: buildAdditionalContext() } : {}),
+      },
+    };
+    process.stdout.write(JSON.stringify(out));
+  } catch (e) {
+    noteHookError(`sessionstart-${SKILL_KEY}`, "main", e);
+    process.stdout.write(JSON.stringify({ hookSpecificOutput: { hookEventName: "SessionStart" } }));
+  }
+}
+
+if (import.meta.main) {
+  void main();
+}

package/hooks/sessionstart-efficient.ts

@@ -0,0 +1,110 @@
+#!/usr/bin/env bun
+/**
+ * sessionstart-efficient.ts — SessionStart hook for the ashlr-efficient output style.
+ *
+ * Injects the ashlr-efficient ruleset as additionalContext when
+ * ~/.ashlr/efficient.json { "enabled": true } (or project-level .ashlr/efficient.json).
+ *
+ * When BOTH ashlr-brief and ashlr-efficient are active, emits a merged block
+ * noting that both rulesets apply.
+ *
+ * Contract: never throws, always exits 0.
+ */
+
+import { existsSync, readFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+
+import { noteHookError } from "./_hook-errors";
+import { resolveActiveLevel } from "./sessionstart-brief";
+
+interface SkillConfig {
+  enabled?: boolean;
+}
+
+interface BriefConfig {
+  level?: string;
+}
+
+interface HookOutput {
+  hookSpecificOutput: {
+    hookEventName: "SessionStart";
+    additionalContext?: string;
+  };
+}
+
+const SKILL_KEY = "efficient";
+
+const EFFICIENT_RULESET = `[ashlr-efficient] Output structure rules active.
+1. Inverted pyramid: lead with the answer, then context/explanation.
+2. Inline code for all identifiers, paths, CLI commands, and config keys.
+3. Tables for 3+ item comparisons (not bulleted prose lists).
+4. No transitional filler: drop "Now that we have X", "As mentioned above", "Moving on to", "Let's now", "With that in mind".
+5. file:line citations instead of quoted blocks (quote only when exact text is load-bearing).`;
+
+const COMBINED_RULESET = `[ashlr-brief + ashlr-efficient] Both output-shaping rulesets are active simultaneously.
+ashlr-brief: reduces prose volume (drops filler words, padding, restating-the-question preambles).
+ashlr-efficient: reshapes structure (answer-first, inline code for identifiers, tables for 3+ comparisons, no transitional filler, file:line citations).
+Auto-clarity exceptions (both suspended): destructive actions, security findings, error messages/stack traces, multi-step migrations, code blocks/diffs.`;
+
+function safeReadJson<T>(path: string): T | null {
+  if (!existsSync(path)) return null;
+  try {
+    return JSON.parse(readFileSync(path, "utf-8")) as T;
+  } catch (e) {
+    noteHookError(`sessionstart-${SKILL_KEY}`, `parse:${path}`, e);
+    return null;
+  }
+}
+
+function findRepoRoot(start: string): string | null {
+  let cur = start;
+  for (let i = 0; i < 10; i++) {
+    if (existsSync(join(cur, ".git")) || existsSync(join(cur, "package.json"))) return cur;
+    const parent = join(cur, "..");
+    if (parent === cur) return null;
+    cur = parent;
+  }
+  return null;
+}
+
+export function isEnabled(opts?: { homeDir?: string; cwd?: string }): boolean {
+  const h = opts?.homeDir ?? (process.env.HOME ?? homedir());
+  const cwd = opts?.cwd ?? process.cwd();
+
+  const repoRoot = findRepoRoot(cwd);
+  if (repoRoot) {
+    const cfg = safeReadJson<SkillConfig>(join(repoRoot, ".ashlr", `${SKILL_KEY}.json`));
+    if (cfg !== null) return cfg.enabled === true;
+  }
+
+  const userCfg = safeReadJson<SkillConfig>(join(h, ".ashlr", `${SKILL_KEY}.json`));
+  return userCfg?.enabled === true;
+}
+
+/** Returns the context string. Detects if ashlr-brief is also active and merges. */
+export function buildAdditionalContext(opts?: { homeDir?: string; cwd?: string }): string {
+  const { level } = resolveActiveLevel(opts);
+  const briefActive = level !== "off";
+  return briefActive ? COMBINED_RULESET : EFFICIENT_RULESET;
+}
+
+async function main(): Promise<void> {
+  try {
+    const enabled = isEnabled();
+    const out: HookOutput = {
+      hookSpecificOutput: {
+        hookEventName: "SessionStart",
+        ...(enabled ? { additionalContext: buildAdditionalContext() } : {}),
+      },
+    };
+    process.stdout.write(JSON.stringify(out));
+  } catch (e) {
+    noteHookError(`sessionstart-${SKILL_KEY}`, "main", e);
+    process.stdout.write(JSON.stringify({ hookSpecificOutput: { hookEventName: "SessionStart" } }));
+  }
+}
+
+if (import.meta.main) {
+  void main();
+}

package/hooks/sessionstart-genome-author.ts

@@ -0,0 +1,93 @@
+#!/usr/bin/env bun
+/**
+ * sessionstart-genome-author.ts — SessionStart hook for the ashlr-genome-author skill.
+ *
+ * Injects the ashlr-genome-author ruleset as additionalContext when
+ * ~/.ashlr/genome-author.json { "enabled": true } (or project-level .ashlr/genome-author.json).
+ *
+ * Contract: never throws, always exits 0.
+ */
+
+import { existsSync, readFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+
+import { noteHookError } from "./_hook-errors";
+
+interface SkillConfig {
+  enabled?: boolean;
+}
+
+interface HookOutput {
+  hookSpecificOutput: {
+    hookEventName: "SessionStart";
+    additionalContext?: string;
+  };
+}
+
+const SKILL_KEY = "genome-author";
+
+const RULESET = `[ashlr-genome-author] Genome proposal discipline active.
+Call ashlr__genome_propose AFTER: new module added, schema change, auth/security change, routing change, or architectural decision.
+Summary format: 2–5 sentences, past tense, ending with affected file paths.
+Do NOT propose for: routine edits, typo fixes, test updates, mid-refactor (wait until stable), or more than once per logical change.
+Use existing manifest section names where possible; introduce new names only for genuinely new architectural concepts.`;
+
+function safeReadJson(path: string): SkillConfig | null {
+  if (!existsSync(path)) return null;
+  try {
+    return JSON.parse(readFileSync(path, "utf-8")) as SkillConfig;
+  } catch (e) {
+    noteHookError(`sessionstart-${SKILL_KEY}`, `parse:${path}`, e);
+    return null;
+  }
+}
+
+function findRepoRoot(start: string): string | null {
+  let cur = start;
+  for (let i = 0; i < 10; i++) {
+    if (existsSync(join(cur, ".git")) || existsSync(join(cur, "package.json"))) return cur;
+    const parent = join(cur, "..");
+    if (parent === cur) return null;
+    cur = parent;
+  }
+  return null;
+}
+
+export function isEnabled(opts?: { homeDir?: string; cwd?: string }): boolean {
+  const h = opts?.homeDir ?? (process.env.HOME ?? homedir());
+  const cwd = opts?.cwd ?? process.cwd();
+
+  const repoRoot = findRepoRoot(cwd);
+  if (repoRoot) {
+    const cfg = safeReadJson(join(repoRoot, ".ashlr", `${SKILL_KEY}.json`));
+    if (cfg !== null) return cfg.enabled === true;
+  }
+
+  const userCfg = safeReadJson(join(h, ".ashlr", `${SKILL_KEY}.json`));
+  return userCfg?.enabled === true;
+}
+
+export function buildAdditionalContext(): string {
+  return RULESET;
+}
+
+async function main(): Promise<void> {
+  try {
+    const enabled = isEnabled();
+    const out: HookOutput = {
+      hookSpecificOutput: {
+        hookEventName: "SessionStart",
+        ...(enabled ? { additionalContext: buildAdditionalContext() } : {}),
+      },
+    };
+    process.stdout.write(JSON.stringify(out));
+  } catch (e) {
+    noteHookError(`sessionstart-${SKILL_KEY}`, "main", e);
+    process.stdout.write(JSON.stringify({ hookSpecificOutput: { hookEventName: "SessionStart" } }));
+  }
+}
+
+if (import.meta.main) {
+  void main();
+}

package/hooks/sessionstart-lean-tools.ts

@@ -0,0 +1,98 @@
+#!/usr/bin/env bun
+/**
+ * sessionstart-lean-tools.ts — SessionStart hook for the ashlr-lean-tools skill.
+ *
+ * Injects the ashlr-lean-tools ruleset as additionalContext when
+ * ~/.ashlr/lean-tools.json { "enabled": true } (or project-level .ashlr/lean-tools.json).
+ *
+ * Contract: never throws, always exits 0.
+ */
+
+import { existsSync, readFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+
+import { noteHookError } from "./_hook-errors";
+
+interface SkillConfig {
+  enabled?: boolean;
+}
+
+interface HookOutput {
+  hookSpecificOutput: {
+    hookEventName: "SessionStart";
+    additionalContext?: string;
+  };
+}
+
+const SKILL_KEY = "lean-tools";
+
+const RULESET = `[ashlr-lean-tools] Highest-impact token-saving habits active.
+1. Read-once: do not re-read a file already in context (it hasn't changed).
+2. Batch edits: use ashlr__multi_edit for 2+ edits to the same file.
+3. Orient before searching: run ashlr__orient once per task before any grep/glob.
+4. Skip verification reads: ashlr__edit and ashlr__write return a diff — do not re-read to confirm.
+5. Grep-before-read: run ashlr__grep first; open the file only if you need more than what grep returned.
+6. Shift to concise output when session spend is high (>5,000 tool-output tokens): file:line citations over quoted blocks, skip preamble.
+7. Use ashlr__bash over native Bash for verbose commands (test runners, git log, find).`;
+
+function safeReadJson(path: string): SkillConfig | null {
+  if (!existsSync(path)) return null;
+  try {
+    return JSON.parse(readFileSync(path, "utf-8")) as SkillConfig;
+  } catch (e) {
+    noteHookError(`sessionstart-${SKILL_KEY}`, `parse:${path}`, e);
+    return null;
+  }
+}
+
+function findRepoRoot(start: string): string | null {
+  let cur = start;
+  for (let i = 0; i < 10; i++) {
+    if (existsSync(join(cur, ".git")) || existsSync(join(cur, "package.json"))) return cur;
+    const parent = join(cur, "..");
+    if (parent === cur) return null;
+    cur = parent;
+  }
+  return null;
+}
+
+export function isEnabled(opts?: { homeDir?: string; cwd?: string }): boolean {
+  const h = opts?.homeDir ?? (process.env.HOME ?? homedir());
+  const cwd = opts?.cwd ?? process.cwd();
+
+  // Project-level wins.
+  const repoRoot = findRepoRoot(cwd);
+  if (repoRoot) {
+    const cfg = safeReadJson(join(repoRoot, ".ashlr", `${SKILL_KEY}.json`));
+    if (cfg !== null) return cfg.enabled === true;
+  }
+
+  // User-level.
+  const userCfg = safeReadJson(join(h, ".ashlr", `${SKILL_KEY}.json`));
+  return userCfg?.enabled === true;
+}
+
+export function buildAdditionalContext(): string {
+  return RULESET;
+}
+
+async function main(): Promise<void> {
+  try {
+    const enabled = isEnabled();
+    const out: HookOutput = {
+      hookSpecificOutput: {
+        hookEventName: "SessionStart",
+        ...(enabled ? { additionalContext: buildAdditionalContext() } : {}),
+      },
+    };
+    process.stdout.write(JSON.stringify(out));
+  } catch (e) {
+    noteHookError(`sessionstart-${SKILL_KEY}`, "main", e);
+    process.stdout.write(JSON.stringify({ hookSpecificOutput: { hookEventName: "SessionStart" } }));
+  }
+}
+
+if (import.meta.main) {
+  void main();
+}

package/hooks/sessionstart-search.ts

@@ -0,0 +1,97 @@
+#!/usr/bin/env bun
+/**
+ * sessionstart-search.ts — SessionStart hook for the ashlr-search skill.
+ *
+ * Injects the ashlr-search ruleset as additionalContext when
+ * ~/.ashlr/search.json { "enabled": true } (or project-level .ashlr/search.json).
+ *
+ * Contract: never throws, always exits 0.
+ */
+
+import { existsSync, readFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+
+import { noteHookError } from "./_hook-errors";
+
+interface SkillConfig {
+  enabled?: boolean;
+}
+
+interface HookOutput {
+  hookSpecificOutput: {
+    hookEventName: "SessionStart";
+    additionalContext?: string;
+  };
+}
+
+const SKILL_KEY = "search";
+
+const RULESET = `[ashlr-search] Genome-aware search habits active.
+1. Run ashlr__orient once per task before any grep or glob.
+2. Use ashlr__grep instead of native Grep — genome-aware, 70–90% lower token cost.
+3. Use ashlr__glob instead of native Glob.
+4. Compose multi-term queries with | alternation (one call beats three).
+5. Trust genome section summaries — do NOT open the referenced file unless you need exact line content for an edit.
+6. Do not re-search patterns already in context.`;
+
+function safeReadJson(path: string): SkillConfig | null {
+  if (!existsSync(path)) return null;
+  try {
+    return JSON.parse(readFileSync(path, "utf-8")) as SkillConfig;
+  } catch (e) {
+    noteHookError(`sessionstart-${SKILL_KEY}`, `parse:${path}`, e);
+    return null;
+  }
+}
+
+function findRepoRoot(start: string): string | null {
+  let cur = start;
+  for (let i = 0; i < 10; i++) {
+    if (existsSync(join(cur, ".git")) || existsSync(join(cur, "package.json"))) return cur;
+    const parent = join(cur, "..");
+    if (parent === cur) return null;
+    cur = parent;
+  }
+  return null;
+}
+
+export function isEnabled(opts?: { homeDir?: string; cwd?: string }): boolean {
+  const h = opts?.homeDir ?? (process.env.HOME ?? homedir());
+  const cwd = opts?.cwd ?? process.cwd();
+
+  // Project-level wins.
+  const repoRoot = findRepoRoot(cwd);
+  if (repoRoot) {
+    const cfg = safeReadJson(join(repoRoot, ".ashlr", `${SKILL_KEY}.json`));
+    if (cfg !== null) return cfg.enabled === true;
+  }
+
+  // User-level.
+  const userCfg = safeReadJson(join(h, ".ashlr", `${SKILL_KEY}.json`));
+  return userCfg?.enabled === true;
+}
+
+export function buildAdditionalContext(): string {
+  return RULESET;
+}
+
+async function main(): Promise<void> {
+  try {
+    const enabled = isEnabled();
+    const out: HookOutput = {
+      hookSpecificOutput: {
+        hookEventName: "SessionStart",
+        ...(enabled ? { additionalContext: buildAdditionalContext() } : {}),
+      },
+    };
+    process.stdout.write(JSON.stringify(out));
+  } catch (e) {
+    noteHookError(`sessionstart-${SKILL_KEY}`, "main", e);
+    process.stdout.write(JSON.stringify({ hookSpecificOutput: { hookEventName: "SessionStart" } }));
+  }
+}
+
+if (import.meta.main) {
+  void main();
+}