linted

Reviewed-on: #4

.eslintignore

@@ -0,0 +1,6 @@
+node_modules/
+logs/
+images/
+dist/
+coverage/
+*.min.js 

.eslintrc.json

@@ -0,0 +1,67 @@
+{
+    "env": {
+        "node": true,
+        "es2022": true
+    },
+    "extends": [
+        "eslint:recommended",
+        "plugin:import/recommended"
+    ],
+    "plugins": [
+        "import"
+    ],
+    "parserOptions": {
+        "ecmaVersion": "latest",
+        "sourceType": "module"
+    },
+    "settings": {
+        "import/resolver": {
+            "node": {
+                "extensions": [
+                    ".js",
+                    ".mjs"
+                ]
+            }
+        }
+    },
+    "rules": {
+        // Error prevention
+        "no-const-assign": "error",
+        "no-dupe-args": "error",
+        "no-dupe-keys": "error",
+        "no-duplicate-case": "error",
+        "no-unreachable": "error",
+        "valid-typeof": "error",
+        
+        // Best practices
+        "eqeqeq": "error",
+        "no-eval": "error",
+        "no-unused-vars": ["error", { "argsIgnorePattern": "^_", "varsIgnorePattern": "^_" }],
+        "no-var": "error",
+        "prefer-const": "error",
+        "no-empty": ["error", { "allowEmptyCatch": true }],
+        
+        // Style
+        "indent": ["error", 4, { "SwitchCase": 1 }],
+        "linebreak-style": ["error", "unix"],
+        "quotes": ["error", "single"],
+        "semi": ["error", "always"],
+        "no-multiple-empty-lines": ["error", { "max": 1 }],
+        "no-trailing-spaces": "error",
+        "eol-last": "error",
+        "no-mixed-spaces-and-tabs": "error",
+        
+        // Object and array formatting
+        "object-curly-spacing": ["error", "always"],
+        "array-bracket-spacing": ["error", "never"],
+        "comma-dangle": ["error", "never"],
+        
+        // Import/Export
+        "import/no-duplicates": "error",
+        "import/order": ["error", {
+            "groups": ["builtin", "external", "internal", "parent", "sibling", "index"],
+            "newlines-between": "always",
+            "alphabetize": { "order": "asc" }
+        }]
+    }
+} 

.gitignore

@@ -3,6 +3,7 @@
 node_modules
 
 .env
+.nvmrc
 images/*
 logs/*
 pocketbase/*

_opt/ansi.js

@@ -0,0 +1,120 @@
+import { MessageFlags } from 'discord-api-types/v10';
+import { SlashCommandBuilder, PermissionFlagsBits } from 'discord.js';
+
+import { CODES } from '../_src/ansiColors.js';
+
+/**
+ * Combined ANSI utilities module
+ *  - /ansi: preview nested [tag]…[/] ANSI coloring
+ *  - /ansitheme: display full BG×FG theme chart
+ * Both commands are Admin-only.
+ */
+export const commands = [
+    // Preview arbitrary ANSI tags
+    {
+        data: new SlashCommandBuilder()
+            .setName('ansi')
+            .setDescription('Preview an ANSI-colored code block')
+            .setDefaultMemberPermissions(PermissionFlagsBits.Administrator)
+            .setDMPermission(false)
+            .addStringOption(opt =>
+                opt
+                    .setName('text')
+                    .setDescription('Use [red]…[/], [bold,blue]…[/], escape \\[/]')
+                    .setRequired(true)
+            )
+            .addBooleanOption(opt =>
+                opt
+                    .setName('ephemeral')
+                    .setDescription('Reply ephemerally?')
+                    .setRequired(false)
+            ),
+        async execute(interaction, client) {
+            const raw = interaction.options.getString('text', true);
+            const ephemeral = interaction.options.getBoolean('ephemeral') ?? true;
+            const colored = client.ansi`${raw}`;
+            const block = client.wrapAnsi(colored);
+            const opts = { content: block };
+            if (ephemeral) opts.flags = MessageFlags.Ephemeral;
+            await interaction.reply(opts);
+        }
+    },
+
+    // Show complete ANSI theme chart
+    {
+        data: new SlashCommandBuilder()
+            .setName('ansitheme')
+            .setDescription('Show ANSI color theme chart')
+            .setDefaultMemberPermissions(PermissionFlagsBits.Administrator)
+            .setDMPermission(false)
+            .addBooleanOption(opt =>
+                opt
+                    .setName('ephemeral')
+                    .setDescription('Reply ephemerally?')
+                    .setRequired(false)
+            ),
+        async execute(interaction, client) {
+            const fgs = ['gray', 'red', 'green', 'yellow', 'blue', 'pink', 'cyan', 'white'];
+            const bgs = ['bgGray', 'bgOrange', 'bgBlue', 'bgTurquoise', 'bgFirefly', 'bgIndigo', 'bgLightGray', 'bgWhite'];
+            const pad = 8;
+            // Column header with padded labels (no colors) - shifted right by 1
+            const header = ' ' + fgs.map(f => f.padEnd(pad, ' ')).join('');
+            // Sample row with no background (padded cells)
+            let defaultRow = '';
+            for (const fg of fgs) {
+                const fgCode = CODES[fg];
+                const openNormal = `\u001b[${fgCode}m`;
+                const openBold   = `\u001b[${fgCode};${CODES.bold}m`;
+                const openUnder  = `\u001b[${fgCode};${CODES.underline}m`;
+                const cell = `${openNormal}sa\u001b[0m${openBold}mp\u001b[0m${openUnder}le\u001b[0m`;
+                defaultRow += ' ' + cell + ' ';
+            }
+            // Append default row label after one pad
+            defaultRow += 'default';
+            // Colored rows per background
+            const rows = [];
+            for (const bg of bgs) {
+                let row = '';
+                const bgCode = CODES[bg];
+                for (const fg of fgs) {
+                    const fgCode = CODES[fg];
+                    const openNormal = `\u001b[${bgCode};${fgCode}m`;
+                    const openBold   = `\u001b[${bgCode};${fgCode};${CODES.bold}m`;
+                    const openUnder  = `\u001b[${bgCode};${fgCode};${CODES.underline}m`;
+                    const cell = `${openNormal}sa\u001b[0m${openBold}mp\u001b[0m${openUnder}le\u001b[0m`;
+                    row += ' ' + cell + ' ';
+                }
+                // Append uncolored row label immediately after cell padding
+                row += bg;
+                rows.push(row);
+            }
+            // Determine ephemeral setting
+            const ephemeral = interaction.options.getBoolean('ephemeral') ?? true;
+            // Initial sample table (header + default row)
+            const sampleContent = [header, defaultRow].join('\n');
+            const optsSample = { content: client.wrapAnsi(sampleContent) };
+            if (ephemeral) optsSample.flags = MessageFlags.Ephemeral;
+            await interaction.reply(optsSample);
+            // Split colored rows into two tables
+            const half = Math.ceil(rows.length / 2);
+            const firstRows = rows.slice(0, half);
+            const secondRows = rows.slice(half);
+            // First colored table
+            const table1 = [header, ...firstRows].join('\n');
+            const opts1 = { content: client.wrapAnsi(table1) };
+            if (ephemeral) opts1.flags = MessageFlags.Ephemeral;
+            await interaction.followUp(opts1);
+            // Second colored table
+            if (secondRows.length > 0) {
+                const table2 = [header, ...secondRows].join('\n');
+                const opts2 = { content: client.wrapAnsi(table2) };
+                if (ephemeral) opts2.flags = MessageFlags.Ephemeral;
+                await interaction.followUp(opts2);
+            }
+        }
+    }
+];
+
+export async function init(client) {
+    client.logger.info('[module:ansi] Loaded ANSI utilities');
+}

_opt/botUtils.js

@@ -0,0 +1,167 @@
+import { MessageFlags } from 'discord-api-types/v10';
+import { SlashCommandBuilder, PermissionFlagsBits, EmbedBuilder } from 'discord.js';
+
+/**
+ * botUtils module - provides administrative bot control commands
+ * Currently implements an owner-only exit command for graceful shutdown.
+ */
+// Define slash commands
+export const commands = [
+    {
+        data: new SlashCommandBuilder()
+            .setName('exit')
+            .setDescription('Gracefully shutdown the bot (Owner only)')
+        // Restrict to server administrators by default
+            .setDefaultMemberPermissions(PermissionFlagsBits.Administrator)
+            .setDMPermission(false)
+            .addIntegerOption(option =>
+                option
+                    .setName('code')
+                    .setDescription('Exit code to use (default 0)')
+                    .setRequired(false)
+            ),
+        /**
+     * Execute the exit command: only the configured owner can invoke.
+     * @param {import('discord.js').CommandInteraction} interaction
+     * @param {import('discord.js').Client} client
+     */
+        async execute(interaction, client) {
+            const ownerId = client.config.owner;
+            // Check invoking user is the bot owner
+            if (interaction.user.id !== String(ownerId)) {
+                return interaction.reply({ content: 'Only the bot owner can shutdown the bot.', flags: MessageFlags.Ephemeral });
+            }
+            // Determine desired exit code (default 0)
+            const exitCode = interaction.options.getInteger('code') ?? 0;
+            // Validate exit code bounds
+            if (exitCode < 0 || exitCode > 254) {
+                return interaction.reply({ content: 'Exit code must be between 0 and 254 inclusive.', flags: MessageFlags.Ephemeral });
+            }
+            // Acknowledge before shutting down
+            await interaction.reply({ content: `Shutting down with exit code ${exitCode}...`, flags: MessageFlags.Ephemeral });
+            client.logger.info(
+                `[cmd:exit] Shutdown initiated by owner ${interaction.user.tag} (${interaction.user.id}), exit code ${exitCode}`
+            );
+            // Destroy Discord client and exit process
+            try {
+                await client.destroy();
+            } catch (err) {
+                client.logger.error(`[cmd:exit] Error during client.destroy(): ${err}`);
+            }
+            process.exit(exitCode);
+        }
+    },
+    /**
+   * Slash command `/status` (Administrator only):
+   * Shows this bot client's status including CPU, memory, environment,
+   * uptime, module list, and entity counts. Optionally displays Git info
+   * (Git Reference and Git Status) when the gitUtils module is loaded.
+   * @param {import('discord.js').CommandInteraction} interaction
+   * @param {import('discord.js').Client} client
+   */
+    // /status: admin-only, shows current client info
+    {
+        data: new SlashCommandBuilder()
+            .setName('status')
+            .setDescription('Show this bot client status and process info')
+            .setDefaultMemberPermissions(PermissionFlagsBits.Administrator)
+            .setDMPermission(false)
+            .addBooleanOption(option =>
+                option
+                    .setName('ephemeral')
+                    .setDescription('Whether the response should be ephemeral')
+                    .setRequired(false)
+            ),
+        async execute(interaction, client) {
+            const ephemeral = interaction.options.getBoolean('ephemeral') ?? true;
+            await interaction.deferReply({ flags: ephemeral ? MessageFlags.Ephemeral : undefined });
+            // Process metrics
+            const uptimeSec = process.uptime();
+            const hours = Math.floor(uptimeSec / 3600);
+            const minutes = Math.floor((uptimeSec % 3600) / 60);
+            const seconds = Math.floor(uptimeSec % 60);
+            const uptime = `${hours}h ${minutes}m ${seconds}s`;
+            const mem = process.memoryUsage();
+            const toMB = bytes => (bytes / 1024 / 1024).toFixed(2);
+            const memoryInfo = `RSS: ${toMB(mem.rss)} MB, Heap: ${toMB(mem.heapUsed)}/${toMB(mem.heapTotal)} MB`;
+            const cpu = process.cpuUsage();
+            const cpuInfo = `User: ${(cpu.user / 1000).toFixed(2)} ms, System: ${(cpu.system / 1000).toFixed(2)} ms`;
+            const nodeVersion = process.version;
+            const platform = `${process.platform} ${process.arch}`;
+            // Client-specific stats
+            const guildCount = client.guilds.cache.size;
+            const userCount = client.guilds.cache.reduce((sum, g) => sum + (g.memberCount || 0), 0);
+            const commandCount = client.commands.size;
+            // List of loaded optional modules
+            const loadedModules = client.modules ? Array.from(client.modules.keys()) : [];
+            // Build embed for status
+            // Determine if gitUtils module is loaded
+            const gitLoaded = client.modules?.has('gitUtils');
+            let branch, build, statusRaw, statusBlock;
+            if (gitLoaded) {
+                const git = client.modules.get('gitUtils');
+                try {
+                    branch = await git.getBranch();
+                    build = await git.getShortHash();
+                    statusRaw = await git.getStatusShort();
+                    // Format status as fenced code block using template literals
+                    // Normalize each line with a leading space in a code fence
+                    // Prefix raw status output with a single space
+                    // Prefix raw status output with a space, and only if non-empty
+                    if (statusRaw) {
+                        statusBlock = '```\n ' + statusRaw + '\n```';
+                    }
+                } catch {
+                    branch = 'error';
+                    build = 'error';
+                    // Represent error status in code fence
+                    statusBlock = '```\n (error)\n```';
+                }
+            }
+            // Prepare module list as bullet points
+            const moduleList = loadedModules.length > 0
+                ? loadedModules.map(m => `• ${m}`).join('\n')
+                : 'None';
+            // Assemble fields
+            const fields = [];
+            // Client identification
+            fields.push({ name: 'Client', value: client.config.id, inline: false });
+            // Performance metrics
+            fields.push({ name: 'CPU Usage', value: cpuInfo, inline: false });
+            fields.push({ name: 'Memory', value: memoryInfo, inline: false });
+            // Environment
+            fields.push({ name: 'Node.js', value: nodeVersion, inline: true });
+            fields.push({ name: 'Platform', value: platform, inline: true });
+            // Uptime
+            fields.push({ name: 'Uptime', value: uptime, inline: true });
+            // Loaded modules
+            fields.push({ name: 'Modules', value: moduleList, inline: false });
+            // Entity counts
+            fields.push({ name: 'Commands', value: commandCount.toString(), inline: true });
+            fields.push({ name: 'Guilds', value: guildCount.toString(), inline: true });
+            fields.push({ name: 'Users', value: userCount.toString(), inline: true });
+            // Git reference and status if available
+            if (gitLoaded) {
+                fields.push({ name: 'Git Reference', value: `${branch}/${build}`, inline: false });
+                fields.push({ name: 'Git Status', value: statusBlock, inline: false });
+            }
+            // Create embed
+            const embed = new EmbedBuilder()
+                .setAuthor({ name: 'ClientX', iconURL: client.user.displayAvatarURL() })
+                .setThumbnail(client.user.displayAvatarURL())
+                .addFields(fields)
+                .setTimestamp();
+            await interaction.editReply({ embeds: [embed] });
+            client.logger.info(`[cmd:status] Returned status embed for client ${client.config.id}`);
+        }
+    }
+];
+
+// Module loaded logging
+export async function init(_client, _clientConfig) {
+    _client.logger.info('[module:botUtils] Module loaded');
+}
+
+export async function handleInteractionCreate(_client, _clientConfig, _interaction) {
+    // ... existing code ...
+}

_opt/condimentX.js

@@ -78,7 +78,6 @@ export const init = async (client, config) => {
     // Used as a prefix before any line that runs within a loop.
     const bullet = '>';
 
-
     // === OpenAI Interaction ===
     // Chat completion via OpenAI with provided instructions.
     async function ai(prompt = '') {
@@ -86,17 +85,17 @@ export const init = async (client, config) => {
             debug(`**AI Prompt**: ${prompt}`);
 
             // Read instructions.
-            let openAIInstructions = fs.readFileSync(openAIInstructionsFile, 'utf8');
+            const openAIInstructions = fs.readFileSync(openAIInstructionsFile, 'utf8');
             const unmention = /<@(\w+)>/g;
             const completion = await openai.chat.completions.create({
                 model: 'gpt-4o-mini',
                 messages: [
-                    {role: 'user', content: `${prompt.replace(unmention, '$1')}`},
+                    { role: 'user', content: `${prompt.replace(unmention, '$1')}` },
-                    {role: 'system', content: `${openAIInstructions}`},
+                    { role: 'system', content: `${openAIInstructions}` }
-                ],
+                ]
             });
-            let chunk = completion.choices[0]?.message?.content;
+            const chunk = completion.choices[0]?.message?.content;
-            if (chunk != '') {
+            if (chunk !== '') {
                 for (const line of chunk.split(/\n\s*\n/).filter(Boolean)) {
                     debug(`${bullet} ${line}`);
                     openAIWebhookClient.send(line);
@@ -142,7 +141,7 @@ export const init = async (client, config) => {
 
     // === Message Fetching Helpers ===
     // Retrieve recent messages from every text channel since a given timestamp.
-    async function fetchRecentMessages(since) {
+    async function _fetchRecentMessages(since) {
         const allMessages = new Collection();
 
         // Get all text channels in the guild
@@ -181,7 +180,7 @@ export const init = async (client, config) => {
             debug(`**Incident Cycle #${incidentCounter++}**`);
 
             // Rebuild the list of current index cases, if any.
-            let indexesList = guild.members.cache.filter(member => member.roles.cache.has(indexRole.id));
+            const indexesList = guild.members.cache.filter(member => member.roles.cache.has(indexRole.id));
             debug(`${bullet} Index Cases: **${indexesList.size}**`);
 
             // Build the victimsList using whitelisted roles.
@@ -206,7 +205,7 @@ export const init = async (client, config) => {
             }
 
             // Conditions for potentially starting an incident.
-            if (indexesList.size == 0 && victimsList.size > 0) {
+            if (indexesList.size === 0 && victimsList.size > 0) {
                 if ((Math.floor(Math.random() * incidenceDenominator) + 1) === 1) {
                     debug(`${bullet} Incidence Check: **Success**`);
                     const newIndex = victimsList.random();
@@ -240,7 +239,7 @@ export const init = async (client, config) => {
             }
 
             // Prepare the next cycle.
-            let interval = cycleInterval + Math.floor(Math.random() * (2 * cycleIntervalRange + 1)) - cycleIntervalRange;
+            const interval = cycleInterval + Math.floor(Math.random() * (2 * cycleIntervalRange + 1)) - cycleIntervalRange;
             setTimeout(cycleIncidents, interval);
             debug(`${bullet} Cycle #${incidentCounter} **<t:${Math.floor((Date.now() + interval) / 1000)}:R>** at **<t:${Math.floor((Date.now() + interval) / 1000)}:t>**`);
         } catch (error) {
@@ -291,7 +290,6 @@ export const init = async (client, config) => {
             if (message.webhookId) return;
             guild = client.guilds.cache.get(guildID);
 
-
             // Someone mentioned us - respond if openAI is enabled, the message was in the webhook channel,  and a trigger was used.
             if (openAI === true && openAIWebhook.channel.id === message.channel.id && openAITriggers.some(word => message.content.replace(/[^\w\s]/gi, '').toLowerCase().includes(word.toLowerCase()))) {
                 // Also check if an active incident is required to respond.
@@ -334,7 +332,7 @@ export const init = async (client, config) => {
             let percentage = Math.min(infections / prox.size * 100, probabilityLimit);
 
             // Reduce base probability by ${antiViralEffectiveness}% for those with ${antiViralRole}
-            if (message.member.roles.cache.has(antiViralRole.id)) {
+            if (message.member.roles.cache.has(antiViralRole.id) && Math.random() * 100 === antiViralEffectiveness) {
                 percentage = Math.round(percentage - (antiViralEffectiveness * (percentage / 100)));
             }
 
@@ -362,11 +360,11 @@ export const init = async (client, config) => {
 
     // Deferred setup on ready
     const readyHandler = async () => {
-        client.logger.info('Initializing CondimentX module');
+        client.logger.info('[module:condimentX] Initializing module');
         if (openAI === true) {
-            openai = new OpenAI({ apiKey: openAIToken });
+            openai = new OpenAI({ apiKey: openAIToken }); // credentials loaded
             openAIWebhook = await client.fetchWebhook(openAIWebhookID, openAIWebhookToken).catch(error => {
-                client.logger.error(`Could not fetch webhook: ${error.message}`);
+                client.logger.error(`[module:condimentX] Could not fetch webhook: ${error.message}`);
                 return null;
             });
             if (openAIWebhook) openAIWebhookClient = new WebhookClient({ id: openAIWebhookID, token: openAIWebhookToken });
@@ -374,7 +372,7 @@ export const init = async (client, config) => {
         try {
             guild = client.guilds.cache.get(guildID);
             if (!guild) {
-                client.logger.error(`CondimentX error: Guild ${guildID} not found`);
+                client.logger.error(`[module:condimentX] Guild ${guildID} not found`);
                 return;
             }
             indexRole = await guild.roles.fetch(indexRoleID);

_opt/gitUtils.js

@@ -0,0 +1,179 @@
+import { execFile } from 'child_process';
+import { promisify } from 'util';
+
+import { MessageFlags } from 'discord-api-types/v10';
+import { SlashCommandBuilder } from 'discord.js';
+// Use execFile to avoid shell interpretation of arguments
+const execFileAsync = promisify(execFile);
+
+// Wrap Git errors
+class GitError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'GitError';
+    }
+}
+
+/**
+ * Execute a git command with given arguments and return its output.
+ * @param {string[]} args - Git command arguments (e.g., ['status', '--porcelain']).
+ * @returns {Promise<string>} - Trimmed stdout or stderr from the command.
+ * @throws {GitError} - When the git command exits with an error.
+ */
+async function runGit(args) {
+    // Sanitize arguments: disallow dangerous shell metacharacters
+    if (!Array.isArray(args)) {
+        throw new GitError('Invalid git arguments');
+    }
+    const dangerous = /[;&|<>`$\\]/;
+    for (const arg of args) {
+        if (dangerous.test(arg)) {
+            throw new GitError(`Illegal character in git argument: ${arg}`);
+        }
+    }
+    try {
+    // Exec git directly without shell
+        const { stdout, stderr } = await execFileAsync('git', args);
+        const out = (stdout || stderr || '').toString().trim();
+        return out || '(no output)';
+    } catch (err) {
+        const msg = err.stderr?.toString().trim() || err.message;
+        throw new GitError(msg);
+    }
+}
+
+/**
+ * Wrap content into a Markdown code block, optionally specifying a language.
+ * @param {string} content - The text to wrap in a code block.
+ * @param {string} [lang] - Optional language identifier (e.g., 'js').
+ * @returns {string} - The content wrapped in triple backticks.
+ */
+function formatCodeBlock(content, lang = '') {
+    const fence = '```';
+    return lang
+        ? `${fence}${lang}\n${content}\n${fence}`
+        : `${fence}\n${content}\n${fence}`;
+}
+
+/**
+ * Split a large string into smaller chunks for message limits.
+ * @param {string} str - The input string to split.
+ * @param {number} chunkSize - Maximum length of each chunk.
+ * @returns {string[]} - An array of substring chunks.
+ */
+function chunkString(str, chunkSize) {
+    const chunks = [];
+    for (let i = 0; i < str.length; i += chunkSize) {
+        chunks.push(str.slice(i, i + chunkSize));
+    }
+    return chunks;
+}
+
+// Single /git command: run arbitrary git <args>
+export const commands = [
+    {
+        data: new SlashCommandBuilder()
+            .setName('git')
+            .setDescription('Run an arbitrary git command (Owner only)')
+            .addStringOption(opt =>
+                opt.setName('args')
+                    .setDescription('Arguments to pass to git')
+                    .setRequired(true))
+            .addBooleanOption(opt =>
+                opt.setName('ephemeral')
+                    .setDescription('Make the reply ephemeral')
+                    .setRequired(false)),
+        async execute(interaction, client) {
+            const ownerId = client.config.owner;
+            if (interaction.user.id !== ownerId) {
+                return interaction.reply({ content: 'Only the bot owner can run git commands.', flags: MessageFlags.Ephemeral });
+            }
+            const raw = interaction.options.getString('args');
+            // Disallow semicolons to prevent command chaining
+            if (raw.includes(';')) {
+                return interaction.reply({ content: 'Semicolons are not allowed in git arguments.', flags: MessageFlags.Ephemeral });
+            }
+            const ephemeral = interaction.options.getBoolean('ephemeral') ?? true;
+            const args = raw.match(/(?:[^\s"]+|"[^"]*")+/g)
+                .map(s => s.replace(/^"(.+)"$/, '$1'));
+
+            try {
+                // Log the exact git command being executed
+                const cmdStr = args.join(' ');
+                client.logger.warn(`[cmd:git] Executing git command: git ${cmdStr}`);
+                const output = await runGit(args);
+                // Prepend the git command as a header; keep it intact when chunking
+                const header = `git ${cmdStr}\n`;
+                // Discord message limit ~2000; reserve for code fences
+                const maxContent = 1990;
+                // Calculate how much output can fit after the header in the first chunk
+                const firstChunkSize = Math.max(0, maxContent - header.length);
+                // Split the raw output into chunks
+                const outputChunks = chunkString(output, firstChunkSize);
+                // Send first block with header + first output chunk
+                const firstBlock = header + (outputChunks[0] || '');
+                const replyOpts = { content: formatCodeBlock(firstBlock) };
+                if (ephemeral) replyOpts.flags = MessageFlags.Ephemeral;
+                await interaction.reply(replyOpts);
+                // Send any remaining blocks without the header
+                for (let i = 1; i < outputChunks.length; i++) {
+                    const fuOpts = { content: formatCodeBlock(outputChunks[i]) };
+                    if (ephemeral) fuOpts.flags = MessageFlags.Ephemeral;
+                    await interaction.followUp(fuOpts);
+                }
+            } catch (err) {
+                const msg = err instanceof GitError ? err.message : String(err);
+                await interaction.reply({ content: `Error: ${msg}`, flags: MessageFlags.Ephemeral });
+            }
+        }
+    }
+];
+
+// No special init logic
+export async function init(client) {
+    client.logger.warn('[module:gitUtils] Git utilities module loaded - dangerous module, use with caution');
+}
+// Helper functions for external use
+/**
+ * Get current Git branch name
+ * @returns {Promise<string>}
+ */
+export async function getBranch() {
+    return runGit(['rev-parse', '--abbrev-ref', 'HEAD']);
+}
+/**
+ * Get short commit hash of HEAD
+ * @returns {Promise<string>}
+ */
+export async function getShortHash() {
+    return runGit(['rev-parse', '--short', 'HEAD']);
+}
+/**
+ * Get concise working tree status (git status --porcelain)
+ * @returns {Promise<string>}
+ */
+export async function getStatusShort() {
+    return runGit(['status', '--porcelain']);
+}
+/**
+ * Get Git remote origin URL
+ * @returns {Promise<string>}
+ */
+export async function getRemoteUrl() {
+    return runGit(['config', '--get', 'remote.origin.url']);
+}
+/**
+ * Get recent commit log (n lines, one-line format)
+ * @param {number} [n=5]
+ * @returns {Promise<string>}
+ */
+export async function getLog(n = 5) {
+    return runGit(['log', `-n${n}`, '--oneline']);
+}
+/**
+ * Get diff summary (git diff --stat)
+ * @returns {Promise<string>}
+ */
+export async function getDiffStat() {
+    return runGit(['diff', '--stat']);
+}

_opt/messageQueue-example.js

@@ -0,0 +1,28 @@
+// _opt/messageQueue-example.js
+import { onMessageQueueEvent } from './pbUtils.js';
+
+/**
+ * Example module that listens for 'test' messages in the message_queue collection.
+ */
+export async function init(client, _config) {
+    client.logger.info('[module:messageQueueExample] Message Queue Example module initialized');
+    onMessageQueueEvent(client, async (action, record) => {
+    // Only process newly created records
+        if (action !== 'create') return;
+        // Only process messages meant for this client
+        if (record.destination !== client.config.id) return;
+        // Only handle test dataType
+        if (record.dataType !== 'test') return;
+
+        // At this point we have a test message for us
+        client.logger.info('[module:messageQueueExample] Test message received');
+
+        // Delete the processed message from the queue
+        try {
+            await client.pb.deleteMessageQueue(record.id);
+            client.logger.debug(`[module:messageQueueExample] Deleted message_queue record ${record.id}`);
+        } catch (err) {
+            client.logger.error(`[module:messageQueueExample] Failed to delete message_queue record ${record.id}: ${err.message}`);
+        }
+    });
+}

_opt/pbUtils.js

@@ -1,6 +1,7 @@
 // _opt/pbutils.js
 // Polyfill global EventSource for PocketBase realtime in Node.js (using CommonJS require)
 import { createRequire } from 'module';
+
 const require = createRequire(import.meta.url);
 const { EventSource } = require('eventsource');
 if (typeof global.EventSource === 'undefined') {
@@ -16,10 +17,10 @@ if (typeof global.EventSource === 'undefined') {
  * @param {Object} client - Discord client with attached PocketBase instance
  * @param {Object} config - Client configuration
  */
-export const init = async (client, config) => {
+export async function init(client, _config) {
     const { pb, logger } = client;
 
-    logger.info('Initializing PocketBase utilities module');
+    logger.info('[module:pbUtils] Initializing PocketBase utilities module');
 
     // Attach utility methods to the pb object
     extendPocketBase(client, pb, logger);
@@ -33,15 +34,15 @@ export const init = async (client, config) => {
             client.emit('message_queue_event', e.action, e.record);
             logger.debug(`PubSub event: ${e.action} on message_queue: ${JSON.stringify(e.record)}`);
         });
-    logger.info('Subscribed to PocketBase message_queue realtime events');
+        logger.info('[module:pbUtils] Subscribed to PocketBase message_queue realtime events');
     } catch (error) {
-    logger.error(`Failed to subscribe to message_queue realtime: ${error.message}`);
+        logger.error(`[module:pbUtils] Failed to subscribe to message_queue realtime: ${error.message}`);
     }
 
-// end of init()
+    // end of init()
 
     logger.info('PocketBase utilities module initialized');
-};
+}
 
 /**
  * Register a handler for incoming message_queue pub/sub events.
@@ -54,7 +55,7 @@ export function onMessageQueueEvent(client, handler) {
         try {
             handler(action, record);
         } catch (err) {
-      client.logger.error(`Error in message_queue handler: ${err.message}`);
+            client.logger.error(`[module:pbUtils] Error in message_queue handler: ${err.message}`);
         }
     });
 }
@@ -215,9 +216,9 @@ const extendPocketBase = (client, pb, logger) => {
         const records = [];
         const pageSize = options.pageSize || 200;
         let page = 1;
-
+        const isRunning = true;
+        while (isRunning) {
             try {
-			while (true) {
                 const result = await pb.collection(collection).getList(page, pageSize, options);
                 records.push(...result.items);
 
@@ -226,13 +227,13 @@ const extendPocketBase = (client, pb, logger) => {
                 }
 
                 page++;
-			}
-
-			return records;
             } catch (error) {
                 logger.error(`Failed to get all records from ${collection}: ${error.message}`);
                 throw error;
             }
+        }
+
+        return records;
     };
 
     /**
@@ -361,30 +362,6 @@ const extendPocketBase = (client, pb, logger) => {
         return await pb.deleteOne('message_queue', id);
     };
 
-	// ===== PUB/SUB OPERATIONS =====
-
-	/**
-	 * Publish a message into the "message_queue" collection.
-	 * @param {string} source - Origin identifier for the message.
-	 * @param {string} destination - Target identifier (e.g. channel or client ID).
-	 * @param {string} dataType - A short string describing the type of data.
-	 * @param {object} data - The payload object to deliver.
-	 * @returns {Promise<object>} The created message_queue record.
-	 */
-	pb.publishMessage = async (source, destination, dataType, data) => {
-		try {
-			return await pb.collection('message_queue').create({
-				source,
-				destination,
-				dataType,
-				data: JSON.stringify(data)
-			});
-		} catch (error) {
-			logger.error(`Failed to publish message to message_queue: ${error.message}`);
-			throw error;
-		}
-	};
-
     // ===== CACHE MANAGEMENT =====
 
     // Simple in-memory cache
@@ -509,10 +486,12 @@ const setupConnectionHandling = (pb, logger) => {
                 logger.info('Reconnecting to PocketBase...');
                 // Attempt to refresh the auth if we have a refresh token
                 if (pb.authStore.token && pb.authStore.model?.id) {
-					await pb.admins.authRefresh();
+                // Refresh session using the configured users collection
+                    await pb.collection('_users').authRefresh();
                 } else if (pb._config.username && pb._config.password) {
                     // Fall back to full re-authentication if credentials available
-					await pb.admins.authWithPassword(
+                // Re-authenticate using the configured users collection credentials
+                    await pb.collection('_users').authWithPassword(
                         pb._config.username,
                         pb._config.password
                     );

_opt/responses.js

@@ -3,11 +3,15 @@
  * Listens to message events, sends chat queries to the OpenAI Responses API,
  * and handles text or image (function_call) outputs.
  */
+// Removed local file fallback; prompt now comes exclusively from PocketBase via responsesPrompt module
 import fs from 'fs/promises';
 import path from 'path';
-import { OpenAI } from 'openai';
+
 import axios from 'axios';
 import { AttachmentBuilder, PermissionFlagsBits } from 'discord.js';
+import { OpenAI } from 'openai';
+
+import { expandTemplate } from '../_src/template.js';
 
 // Discord message max length
 const MAX_DISCORD_MSG_LENGTH = 2000;
@@ -24,7 +28,7 @@ function splitMessage(text, maxLength = MAX_DISCORD_MSG_LENGTH) {
     let chunk = '';
     let codeBlockOpen = false;
     let codeBlockFence = '```';
-  for (let line of lines) {
+    for (const line of lines) {
         const trimmed = line.trim();
         const isFenceLine = trimmed.startsWith('```');
         if (isFenceLine) {
@@ -70,36 +74,17 @@ function splitMessage(text, maxLength = MAX_DISCORD_MSG_LENGTH) {
     return chunks.map(c => c.endsWith('\n') ? c.slice(0, -1) : c);
 }
 
-/**
- * Load AI system prompt text from a file.
- * @param {string} filePath - Path to the prompt file.
- * @param {object} logger - Logger instance for reporting.
- * @returns {Promise<string>} Promise resolving to the prompt text or empty string.
- */
-async function loadSystemPrompt(filePath, logger) {
-  try {
-    const prompt = await fs.readFile(path.resolve(filePath), 'utf8');
-    logger.info(`Loaded system prompt: ${filePath}`);
-    return prompt;
-  } catch (err) {
-    logger.error(`Failed to load system prompt: ${err.message}`);
-    return '';
-  }
-}
-
 /**
  * Determine whether the bot should respond to a message.
- * Triggers when the bot is mentioned or when the message is a direct reply.
+ * Controlled by enableMentions and enableReplies in config.
- * @param {Message} message - The incoming Discord message.
- * @param {string} botId - The bot user ID.
- * @param {object} logger - Logger for debugging.
- * @returns {Promise<boolean>} True if the bot should respond.
  */
-async function shouldRespond(message, botId, logger) {
+async function shouldRespond(message, botId, cfg, logger) {
     if (message.author.bot || !botId) return false;
-  const isMention = message.mentions.users.has(botId);
+    const enableMentions = cfg.enableMentions ?? true;
+    const enableReplies  = cfg.enableReplies  ?? true;
+    const isMention = enableMentions && message.mentions.users.has(botId);
     let isReply = false;
-  if (message.reference?.messageId) {
+    if (enableReplies && message.reference?.messageId) {
         try {
             const ref = await message.channel.messages.fetch(message.reference.messageId);
             isReply = ref.author.id === botId;
@@ -129,7 +114,7 @@ function cacheResponse(client, key, id, ttlSeconds) {
  */
 function awardOutput(client, guildId, userId, amount) {
     if (client.scorekeeper && amount > 0) {
-    client.scorekeeper.addOutput(guildId, userId, amount)
+        client.scorekeeper.addOutput(guildId, userId, amount, 'AI_response')
             .catch(err => client.logger.error(`Scorekeeper error: ${err.message}`));
     }
 }
@@ -149,7 +134,7 @@ async function handleImage(client, message, resp, cfg) {
     if (!fn?.arguments) return false;
     client.logger.debug(`Image function args: ${fn.arguments}`);
     let args;
-  try { args = JSON.parse(fn.arguments); } catch { return false; }
+    try { args = JSON.parse(fn.arguments); } catch (e) { return false; }
     if (!args.prompt?.trim()) {
         await message.reply('Cannot generate image: empty prompt.');
         return true;
@@ -159,7 +144,7 @@ async function handleImage(client, message, resp, cfg) {
     const promptText = args.prompt;
     // Determine number of images (1-10); DALL·E-3 only supports 1
     let count = 1;
-  if (args.n != null) {
+    if (args.n !== null) {
         const nVal = typeof args.n === 'number' ? args.n : parseInt(args.n, 10);
         if (!Number.isNaN(nVal)) count = nVal;
     }
@@ -237,6 +222,12 @@ async function handleImage(client, message, resp, cfg) {
             client.logger.info(`Saved image: ${filePath}`);
             attachments.push(new AttachmentBuilder(buffer, { name: filename }));
         }
+        // Award output points based on token usage for image generation
+        const tokens = imgRes.usage?.total_tokens ?? count;
+        if (client.scorekeeper && tokens > 0) {
+            client.scorekeeper.addOutput(message.guild.id, message.author.id, tokens, 'image_generation')
+                .catch(err => client.logger.error(`Scorekeeper error: ${err.message}`));
+        }
         // Reply with attachments
         await message.reply({ content: promptText, files: attachments });
     } catch (err) {
@@ -256,8 +247,9 @@ async function handleImage(client, message, resp, cfg) {
 async function onMessage(client, cfg, message) {
     const logger = client.logger;
     const botId = client.user?.id;
-  if (!(await shouldRespond(message, botId, logger))) return;
+    client.logger.debug(`[onMessage] Received message ${message.id} from ${message.author.id}`);
-  await message.channel.sendTyping();
+    // Check if bot should respond, based on config (mentions/replies)
+    if (!(await shouldRespond(message, botId, cfg, logger))) return;
 
     // Determine channel/thread key for context
     const key = message.thread?.id || message.channel.id;
@@ -267,6 +259,12 @@ async function onMessage(client, cfg, message) {
     const last = lockMap.get(key) || Promise.resolve();
     // Handler to run in sequence
     const handler = async () => {
+    // Start typing indicator loop every 9 seconds
+        const typingInterval = setInterval(() => {
+            message.channel.sendTyping().catch(() => {});
+        }, 9000);
+        // Initial typing
+        message.channel.sendTyping().catch(() => {});
         try {
             // Previous response ID for context continuity
             const prev = client.pb?.cache?.get(key);
@@ -286,15 +284,54 @@ async function onMessage(client, cfg, message) {
                     client.logger.error(`Error checking score: ${err.message}`);
                 }
             }
-      // Build request body, prefixing with a mention of who spoke
+            // Build request body, including replied-to message context and mention of who spoke
+            let referencePrefix = '';
+            let referenceMessage = null;
+            if (message.reference?.messageId) {
+                try {
+                    const ref = await message.channel.messages.fetch(message.reference.messageId);
+                    referenceMessage = ref;
+                    const refContent = ref.content || '';
+                    if (ref.author.id === botId) {
+                        referencePrefix = `You said: ${refContent}`;
+                    } else {
+                        referencePrefix = `<@${ref.author.id}> said: ${refContent}`;
+                    }
+                } catch {
+                    // ignore fetch errors
+                }
+            }
             const speakerMention = `<@${message.author.id}>`;
+            const userInput = referencePrefix
+                ? `${referencePrefix}\n${speakerMention} said to you: ${message.content}`
+                : `${speakerMention} said to you: ${message.content}`;
+            // Prepare template context
+            const locationName = message.thread?.name || message.channel.name;
+            const locationId   = message.thread?.id   || message.channel.id;
+            const now = new Date();
+            const date = now.toISOString().split('T')[0];
+            const time = now.toTimeString().split(' ')[0];
+            const datetime = now.toISOString().replace('T',' ').replace(/\..+$/,'');
+            const ctx = {
+                clientId: client.config.id,
+                userName: message.author.username,
+                userId: message.author.id,
+                userTag: message.author.tag,
+                // add guild context
+                guildName: message.guild?.name || '',
+                guildId: message.guild?.id   || '',
+                input: userInput,
+                locationName, locationId,
+                date, time, datetime
+            };
+            const instructions = expandTemplate(client.responsesPrompt, ctx);
             const body = {
                 model: cfg.defaultModel,
-        instructions: client.responsesSystemPrompt,
+                instructions,
-        input: `${speakerMention} said to you: ${message.content}`,
+                input: userInput,
                 previous_response_id: prev,
                 max_output_tokens: cfg.defaultMaxTokens,
-        temperature: cfg.defaultTemperature,
+                temperature: cfg.defaultTemperature
             };
             // Assemble any enabled tools
             const tools = [];
@@ -362,6 +399,23 @@ async function onMessage(client, cfg, message) {
                 body.tools = tools;
             }
 
+            // If there are image attachments in the referenced or current message, wrap text and images into a multimodal message
+            const refImages = referenceMessage
+                ? referenceMessage.attachments.filter(att => /\.(png|jpe?g|gif|webp)$/i.test(att.name || att.url))
+                : new Map();
+            const currImages = message.attachments.filter(att => /\.(png|jpe?g|gif|webp)$/i.test(att.name || att.url));
+            if (refImages.size > 0 || currImages.size > 0) {
+                // build ordered content items: text first, then referenced images, then current images
+                const contentItems = [{ type: 'input_text', text: userInput }];
+                for (const att of refImages.values()) {
+                    contentItems.push({ type: 'input_image', detail: 'auto', image_url: att.url });
+                }
+                for (const att of currImages.values()) {
+                    contentItems.push({ type: 'input_image', detail: 'auto', image_url: att.url });
+                }
+                body.input = [{ type: 'message', role: 'user', content: contentItems }];
+            }
+
             // Call OpenAI Responses
             logger.debug(`Calling AI with body: ${JSON.stringify(body)}`);
             const resp = await client.openai.responses.create(body);
@@ -389,46 +443,15 @@ async function onMessage(client, cfg, message) {
             }
         } catch (err) {
             logger.error(`Queued onMessage error for ${key}: ${err.message}`);
+        } finally {
+            clearInterval(typingInterval);
         }
     };
     // Chain the handler to the last promise
-  const next = last.then(handler).catch(err => logger.error(err));
+    const next = last.then(handler).catch(err => logger.error(`[onMessage] Handler error: ${err.message}`));
     lockMap.set(key, next);
     // Queue enqueued; handler will send response when its turn arrives
     return;
-
-  // Call OpenAI Responses
-  let resp;
-  try {
-    logger.debug(`Calling AI with body: ${JSON.stringify(body)}`);
-    resp = await client.openai.responses.create(body);
-    logger.info(`AI response id=${resp.id}`);
-    // Award tokens for the AI chat response immediately (captures token usage even if image follows)
-    const chatTokens = resp.usage?.total_tokens ?? resp.usage?.completion_tokens ?? 0;
-    awardOutput(client, message.guild.id, message.author.id, chatTokens);
-  } catch (err) {
-    logger.error(`AI error: ${err.message}`);
-    return message.reply('Error generating response.');
-  }
-
-  // Cache for next turn only if this was a text response
-  const isFuncCall = Array.isArray(resp.output) && resp.output.some(o => o.type === 'function_call');
-  if (!isFuncCall && resp.id && cfg.conversationExpiry) {
-    cacheResponse(client, key, resp.id, Math.floor(cfg.conversationExpiry / 1000));
-  }
-
-  // Handle image function call if present
-  if (await handleImage(client, message, resp, cfg)) return;
-
-  // Otherwise reply with text (split if over Discord limit)
-  const text = resp.output_text?.trim();
-  if (text) {
-    const parts = splitMessage(text, MAX_DISCORD_MSG_LENGTH);
-    for (const part of parts) {
-      await message.reply(part);
-    }
-  }
-
 }
 
 /**
@@ -442,21 +465,36 @@ export async function sendNarrative(client, cfg, channelId, text) {
     const logger = client.logger;
     try {
     // Build the narrative instructions
-    const instructions = `${client.responsesSystemPrompt}\n\nGenerate the following as an engaging narrative:`;
+    // Expand template for sendNarrative
+        const now = new Date();
+        const date = now.toISOString().split('T')[0];
+        const time = now.toTimeString().split(' ')[0];
+        const datetime = now.toISOString().replace('T',' ').replace(/\..+$/,'');
+        const ctx = {
+            clientId: client.config.id,
+            userName: client.user.username,
+            userId: client.user.id,
+            input: text,
+            locationName: channel.name,
+            locationId: channel.id,
+            date, time, datetime
+        };
+        const raw = `${client.responsesPrompt}\n\nGenerate the following as an engaging narrative:`;
+        const instructions = expandTemplate(raw, ctx);
         const body = {
             model: cfg.defaultModel,
             instructions,
             input: text,
             max_output_tokens: cfg.defaultMaxTokens,
-      temperature: cfg.defaultTemperature,
+            temperature: cfg.defaultTemperature
         };
-    logger.debug('sendNarrative: calling AI with body', body);
+        logger.debug(`[sendNarrative] Calling AI with body: ${JSON.stringify(body).slice(0,1000)}`);
         const resp = await client.openai.responses.create(body);
-    logger.info(`sendNarrative AI response id=${resp.id}`);
+        logger.info(`[sendNarrative] Received AI response id=${resp.id}`);
         // Fetch the target channel or thread
         const channel = await client.channels.fetch(channelId);
         if (!channel || typeof channel.send !== 'function') {
-      logger.error(`sendNarrative: cannot send to channel ID ${channelId}`);
+            logger.error(`[sendNarrative] Cannot send to channel ID ${channelId}`);
             return;
         }
         // Split the output and send
@@ -468,7 +506,7 @@ export async function sendNarrative(client, cfg, channelId, text) {
             }
         }
     } catch (err) {
-    client.logger.error(`sendNarrative error: ${err.message}`);
+        client.logger.error(`[sendNarrative] Error: ${err.message}`);
     }
 }
 
@@ -482,9 +520,10 @@ export async function sendNarrative(client, cfg, channelId, text) {
  */
 export async function init(client, clientConfig) {
     const cfg = clientConfig.responses;
-  client.logger.info('Initializing Responses module');
+    client.logger.info('[module:responses] Initializing Responses module');
-  client.responsesSystemPrompt = await loadSystemPrompt(cfg.systemPromptPath, client.logger);
+    // Initialize prompt from responsesPrompt module (must be loaded before this)
+    client.responsesPrompt = client.responsesPrompt ?? '';
     client.openai = new OpenAI({ apiKey: cfg.apiKey });
     client.on('messageCreate', m => onMessage(client, cfg, m));
-  client.logger.info('Responses module ready');
+    client.logger.info('[module:responses] Responses module ready');
 }

_opt/responsesPrompt.js

@@ -0,0 +1,155 @@
+import { _fs } from 'fs';
+import { _path } from 'path';
+
+import { _MessageFlags } from 'discord-api-types/v10';
+import { SlashCommandBuilder, PermissionFlagsBits, ModalBuilder, TextInputBuilder, TextInputStyle, ActionRowBuilder } from 'discord.js';
+// Placeholder info for template variables
+const TEMPLATE_KEYS_INFO = 'Available keys: userName, userId, locationName, locationId, date, time, datetime, clientId';
+
+// Modal text input limits
+const MAX_LEN = 4000;
+const MAX_FIELDS = 5;
+
+/**
+ * responsesPrompt module
+ * Implements `/prompt [version]` to edit the current or historical prompt in a single PocketBase collection.
+ * responses_prompts collection holds all versions; newest record per client is the live prompt.
+ */
+export const commands = [
+    {
+        data: new SlashCommandBuilder()
+            .setName('prompt')
+            .setDescription('Edit the AI response prompt (current or past version)')
+            .setDefaultMemberPermissions(PermissionFlagsBits.Administrator)
+            .setDMPermission(false)
+            .addStringOption(opt =>
+                opt.setName('version')
+                    .setDescription('ID of a past prompt version to load')
+                    .setRequired(false)
+                    .setAutocomplete(true)
+            ),
+        async execute(interaction, client) {
+            const _clientId = client.config.id;
+            const versionId = interaction.options.getString('version');
+            // Fetch prompt: live latest or selected historic
+            let promptText = client.responsesPrompt || '';
+            if (versionId) {
+                try {
+                    const rec = await client.pb.getOne('responses_prompts', versionId);
+                    if (rec?.prompt) promptText = rec.prompt;
+                } catch (err) {
+                    client.logger.error(`Failed to load prompt version ${versionId}: ${err.message}`);
+                }
+            }
+            // Prepare modal fields: one SHORT help, then paragraph chunks
+            // Help field
+            const helpField = new TextInputBuilder()
+                .setCustomId('template_help')
+                .setLabel('Template variables (no edits)')
+                .setStyle(TextInputStyle.Short)
+                .setRequired(false)
+            // prefill with the list of usable keys
+                .setValue(TEMPLATE_KEYS_INFO);
+            const modal = new ModalBuilder()
+                .setCustomId(`promptModal-${versionId || 'current'}`)
+                .setTitle('Edit AI Prompt')
+                .addComponents(new ActionRowBuilder().addComponents(helpField));
+            // Prompt chunks
+            const chunks = [];
+            for (let off = 0; off < promptText.length && chunks.length < MAX_FIELDS - 1; off += MAX_LEN) {
+                chunks.push(promptText.slice(off, off + MAX_LEN));
+            }
+            chunks.forEach((text, idx) => {
+                const input = new TextInputBuilder()
+                    .setCustomId(`prompt_${idx}`)
+                    .setLabel(`Part ${idx + 1}`)
+                    .setStyle(TextInputStyle.Paragraph)
+                    .setRequired(idx === 0)
+                    .setMaxLength(MAX_LEN)
+                    .setValue(text);
+                modal.addComponents(new ActionRowBuilder().addComponents(input));
+            });
+            // Empty fields to fill out to MAX_FIELDS
+            for (let i = chunks.length; i < MAX_FIELDS - 1; i++) {
+                modal.addComponents(new ActionRowBuilder().addComponents(
+                    new TextInputBuilder()
+                        .setCustomId(`prompt_${i}`)
+                        .setLabel(`Part ${i + 1}`)
+                        .setStyle(TextInputStyle.Paragraph)
+                        .setRequired(false)
+                        .setMaxLength(MAX_LEN)
+                ));
+            }
+            await interaction.showModal(modal);
+        }
+    }
+];
+
+// Store clients for event hooks
+const _clients = [];
+
+export async function init(client, clientConfig) {
+    const _clientId = client.config.id;
+    client.logger.info('[module:responsesPrompt] initialized');
+    // Load live prompt (latest version)
+    try {
+        const { items } = await client.pb.collection('responses_prompts')
+            .getList(1, 1, { filter: `clientId="${_clientId}"`, sort: '-created' });
+        client.responsesPrompt = items[0]?.prompt || '';
+    } catch (err) {
+        client.logger.error(`Error loading current prompt: ${err.message}`);
+        client.responsesPrompt = '';
+    }
+    _clients.push({ client, clientConfig });
+    // Autocomplete versions
+    client.on('interactionCreate', async interaction => {
+        if (!interaction.isAutocomplete() || interaction.commandName !== 'prompt') return;
+        const focused = interaction.options.getFocused(true);
+        if (focused.name === 'version') {
+            try {
+                const { items } = await client.pb.collection('responses_prompts')
+                    .getList(1, 25, { filter: `clientId="${_clientId}"`, sort: '-created' });
+                const choices = items.map(r => ({ name: new Date(r.created).toLocaleString(), value: r.id }));
+                await interaction.respond(choices);
+            } catch (err) {
+                client.logger.error(`Prompt autocomplete error: ${err.message}`);
+                await interaction.respond([]);
+            }
+        }
+    });
+    // Modal submission: save new version & prune old
+    client.on('interactionCreate', async interaction => {
+        if (!interaction.isModalSubmit()) return;
+        const id = interaction.customId;
+        if (!id.startsWith('promptModal-')) return;
+        const parts = [];
+        for (let i = 0; i < MAX_FIELDS; i++) {
+            try {
+                const v = interaction.fields.getTextInputValue(`prompt_${i}`) || '';
+                if (v.trim()) parts.push(v);
+            } catch {}
+        }
+        const newPrompt = parts.join('\n');
+        // Persist new version
+        let _newRec;
+        try {
+            _newRec = await client.pb.createOne('responses_prompts', { clientId: _clientId, prompt: newPrompt, updatedBy: interaction.user.id });
+            client.responsesPrompt = newPrompt;
+        } catch (err) {
+            client.logger.error(`Failed to save prompt: ${err.message}`);
+            return interaction.reply({ content: `Error saving prompt: ${err.message}`, ephemeral: true });
+        }
+        // Prune older versions beyond the 10 most recent
+        try {
+            const { items } = await client.pb.collection('responses_prompts')
+                .getList(1, 100, { filter: `clientId="${_clientId}"`, sort: '-created' });
+            const toDelete = items.map(r => r.id).slice(10);
+            for (const id of toDelete) {
+                await client.pb.deleteOne('responses_prompts', id);
+            }
+        } catch (err) {
+            client.logger.error(`Failed to prune old prompts: ${err.message}`);
+        }
+        await interaction.reply({ content: 'Prompt saved!', ephemeral: true });
+    });
+}

_opt/responsesQuery.js

@@ -1,12 +1,16 @@
+import fs from 'fs/promises';
+import path from 'path';
+
+import axios from 'axios';
+import { MessageFlags } from 'discord-api-types/v10';
 /**
  * Slash command module for '/query'.
  * Defines and handles the /query command via the OpenAI Responses API,
  * including optional image generation function calls.
  */
 import { SlashCommandBuilder, AttachmentBuilder, PermissionFlagsBits } from 'discord.js';
-import fs from 'fs/promises';
+
-import path from 'path';
+import { expandTemplate } from '../_src/template.js';
-import axios from 'axios';
 
 /**
  * Split long text into chunks safe for Discord messaging.
@@ -46,7 +50,7 @@ async function handleImageInteraction(client, interaction, resp, cfg, ephemeral)
     if (!fn?.arguments) return false;
     client.logger.debug(`Image function args: ${fn.arguments}`);
     let args;
-  try { args = JSON.parse(fn.arguments); } catch { return false; }
+    try { args = JSON.parse(fn.arguments); } catch (e) { return false; }
     if (!args.prompt?.trim()) {
         await interaction.editReply({ content: 'Cannot generate image: empty prompt.', ephemeral });
         return true;
@@ -56,7 +60,7 @@ async function handleImageInteraction(client, interaction, resp, cfg, ephemeral)
     const promptText = args.prompt;
     // Determine number of images (1-10); DALL·E-3 only supports 1
     let count = 1;
-  if (args.n != null) {
+    if (args.n !== null) {
         const nVal = typeof args.n === 'number' ? args.n : parseInt(args.n, 10);
         if (!Number.isNaN(nVal)) count = nVal;
     }
@@ -133,6 +137,12 @@ async function handleImageInteraction(client, interaction, resp, cfg, ephemeral)
             client.logger.info(`Saved image: ${filePath}`);
             attachments.push(new AttachmentBuilder(buffer, { name: filename }));
         }
+        // Award output points based on token usage for image generation
+        const tokens = imgRes.usage?.total_tokens ?? count;
+        if (client.scorekeeper && tokens > 0) {
+            client.scorekeeper.addOutput(interaction.guildId, interaction.user.id, tokens, 'image_generation')
+                .catch(err => client.logger.error(`Scorekeeper error: ${err.message}`));
+        }
         // Reply with attachments
         await interaction.editReply({ content: promptText, files: attachments });
         return true;
@@ -181,12 +191,13 @@ export const commands = [
                         });
                     }
                 } catch (err) {
-          client.logger.error(`Error checking score: ${err.message}`);
+                    client.logger.error(`[cmd:query] Error checking score: ${err.message}`);
-          return interaction.reply({ content: 'Error verifying your score. Please try again later.', ephemeral: true });
+                    return interaction.reply({ content: 'Error verifying your score. Please try again later.', flags: MessageFlags.Ephemeral });
                 }
             }
             const prompt = interaction.options.getString('prompt');
             const flag = interaction.options.getBoolean('ephemeral');
+            client.logger.info(`[cmd:query] Prompt received from ${interaction.user.id}, length=${prompt.length}`);
             const ephemeral = flag !== null ? flag : true;
             await interaction.deferReply({ ephemeral });
 
@@ -198,16 +209,41 @@ export const commands = [
             const last = lockMap.get(key) || Promise.resolve();
             // Handler to run in sequence
             const handler = async () => {
+                // Kick off a repeated typing indicator during processing
+                const typingInterval = setInterval(() => interaction.channel.sendTyping().catch(() => {}), 9000);
+                // initial typing
+                interaction.channel.sendTyping().catch(() => {});
                 // Read previous response ID
                 const previous = client.pb?.cache?.get(key);
                 // Build request body
+                // Expand template for query
+                const now = new Date();
+                const date = now.toISOString().split('T')[0];
+                const time = now.toTimeString().split(' ')[0];
+                const datetime = now.toISOString().replace('T',' ').replace(/\..+$/,'');
+                const channel = await client.channels.fetch(interaction.channelId);
+                const locationName = channel.name;
+                const locationId = channel.id;
+                const ctx = {
+                    clientId: client.config.id,
+                    userName: interaction.user.username,
+                    userId: interaction.user.id,
+                    userTag: interaction.user.tag,
+                    // add guild context
+                    guildName: interaction.guild?.name || '',
+                    guildId: interaction.guild?.id   || '',
+                    input: prompt,
+                    locationName, locationId,
+                    date, time, datetime
+                };
+                const instructions = expandTemplate(client.responsesPrompt, ctx);
                 const body = {
                     model: cfg.defaultModel,
-          instructions: client.responsesSystemPrompt,
+                    instructions,
                     input: prompt,
                     previous_response_id: previous,
                     max_output_tokens: cfg.defaultMaxTokens,
-          temperature: cfg.defaultTemperature,
+                    temperature: cfg.defaultTemperature
                 };
                 // Assemble enabled tools
                 const tools = [];
@@ -264,7 +300,7 @@ export const commands = [
                             required,
                             additionalProperties: false
                         },
-            strict: true,
+                        strict: true
                     });
                 }
                 if (cfg.tools?.webSearch) {
@@ -279,11 +315,12 @@ export const commands = [
                     // Award output tokens
                     const tokens = resp.usage?.total_tokens ?? resp.usage?.completion_tokens ?? 0;
                     if (client.scorekeeper && tokens > 0) {
-            client.scorekeeper.addOutput(interaction.guildId, interaction.user.id, tokens)
+                        client.scorekeeper.addOutput(interaction.guildId, interaction.user.id, tokens, 'AI_query')
                             .catch(e => client.logger.error(`Scorekeeper error: ${e.message}`));
                     }
                 } catch (err) {
                     client.logger.error(`AI error in /query: ${err.message}`);
+                    clearInterval(typingInterval);
                     return interaction.editReply({ content: 'Error generating response.', ephemeral });
                 }
 
@@ -295,11 +332,13 @@ export const commands = [
 
                 // Handle image function call if present
                 if (await handleImageInteraction(client, interaction, resp, cfg, ephemeral)) {
+                    clearInterval(typingInterval);
                     return;
                 }
                 // Send text reply chunks
                 const text = resp.output_text?.trim() || '';
                 if (!text) {
+                    clearInterval(typingInterval);
                     return interaction.editReply({ content: 'No response generated.', ephemeral });
                 }
                 const chunks = splitLongMessage(text, 2000);
@@ -310,6 +349,7 @@ export const commands = [
                         await interaction.followUp({ content: chunks[i], ephemeral });
                     }
                 }
+                clearInterval(typingInterval);
             };
             // Chain handler after last and await
             const next = last.then(handler).catch(err => client.logger.error(`Queued /query error for ${key}: ${err.message}`));

_opt/responsesRandomizer.js

@@ -0,0 +1,37 @@
+/**
+ * responsesRandomizer module
+ * Listens to all guild messages and randomly sends a generated narrative.
+ * Uses sendNarrative from responses.js.
+ */
+
+import { sendNarrative } from './responses.js';
+
+/**
+ * Initialize the responsesRandomizer module.
+ * @param {import('discord.js').Client} client - Discord client instance.
+ * @param {object} clientConfig - Full client configuration object.
+ */
+export async function init(client, clientConfig) {
+    const cfg = clientConfig.responsesRandomizer;
+    const chance = Number(cfg.chance);
+    if (isNaN(chance) || chance <= 0) {
+        client.logger.warn(`[module:responsesRandomizer] Invalid chance value: ${cfg.chance}. Module disabled.`);
+        return;
+    }
+    client.logger.info(`[module:responsesRandomizer] Enabled with chance=${chance}`);
+
+    client.on('messageCreate', async (message) => {
+        try {
+            // Skip bot messages or non-guild messages
+            if (message.author.bot || !message.guild) return;
+            const content = message.content?.trim();
+            if (!content) return;
+            // Roll the dice
+            if (Math.random() > chance) return;
+            // Generate and send narrative
+            await sendNarrative(client, clientConfig.responses, message.channel.id, content);
+        } catch (err) {
+            client.logger.error(`[module:responsesRandomizer] Error processing message: ${err.message}`);
+        }
+    });
+}

_opt/scExecHangarStatus.js

@@ -1,3 +1,4 @@
+import { _MessageFlags } from 'discord-api-types/v10';
 // _opt/schangar.js
 import { SlashCommandBuilder } from 'discord.js';
 
@@ -39,7 +40,7 @@ export const commands = [
                         }
                     }
                 } catch (error) {
-					client.logger.error(`Failed to parse timestamp in hangarsync command: ${error.message}`);
+                    client.logger.error(`[cmd:hangarsync] Failed to parse timestamp: ${error.message}`);
                     return interaction.reply({
                         content: 'Failed to parse timestamp. Please use Unix time in seconds or a valid ISO 8601 string.',
                         ephemeral: true
@@ -51,7 +52,7 @@ export const commands = [
 
             // Check PocketBase connection status
             if (!isPocketBaseConnected(client)) {
-				client.logger.error('PocketBase not connected when executing hangarsync command');
+                client.logger.error('[cmd:hangarsync] PocketBase not connected');
 
                 // Try to reconnect if available
                 if (typeof client.pb.ensureConnection === 'function') {
@@ -99,38 +100,38 @@ export const commands = [
                     if (typeof client.pb.updateOne === 'function') {
                         await client.pb.updateOne('command_hangarsync', record.id, {
                             userId: `${interaction.user.id}`,
-							epoch: `${syncEpoch}`,
+                            epoch: `${syncEpoch}`
                         });
                     } else {
                         await client.pb.collection('command_hangarsync').update(record.id, {
                             userId: `${interaction.user.id}`,
-							epoch: `${syncEpoch}`,
+                            epoch: `${syncEpoch}`
                         });
                     }
-					client.logger.info(`Updated hangarsync for guild ${interaction.guildId} by user ${interaction.user.id}`);
+                    client.logger.info(`[cmd:hangarsync] Updated hangarsync for guild ${interaction.guildId} by user ${interaction.user.id}`);
                 } else {
                     // Create new record
                     if (typeof client.pb.createOne === 'function') {
                         await client.pb.createOne('command_hangarsync', {
                             guildId: `${interaction.guildId}`,
                             userId: `${interaction.user.id}`,
-							epoch: `${syncEpoch}`,
+                            epoch: `${syncEpoch}`
                         });
                     } else {
                         await client.pb.collection('command_hangarsync').create({
                             guildId: `${interaction.guildId}`,
                             userId: `${interaction.user.id}`,
-							epoch: `${syncEpoch}`,
+                            epoch: `${syncEpoch}`
                         });
                     }
-					client.logger.info(`Created new hangarsync for guild ${interaction.guildId} by user ${interaction.user.id}`);
+                    client.logger.info(`[cmd:hangarsync] Created new hangarsync for guild ${interaction.guildId} by user ${interaction.user.id}`);
                 }
 
                 await interaction.reply(`Executive hangar status has been synced: <t:${Math.ceil(syncEpoch / 1000)}>`);
             } catch (error) {
-				client.logger.error(`Error in hangarsync command: ${error.message}`);
+                client.logger.error(`[cmd:hangarsync] Error: ${error.message}`);
                 await interaction.reply({
-					content: `Error syncing hangar status. Please try again later.`,
+                    content: 'Error syncing hangar status. Please try again later.',
                     ephemeral: true
                 });
             }
@@ -150,7 +151,7 @@ export const commands = [
 
             // Check PocketBase connection status
             if (!isPocketBaseConnected(client)) {
-				client.logger.error('PocketBase not connected when executing hangarstatus command');
+                client.logger.error('[cmd:hangarstatus] PocketBase not connected');
 
                 // Try to reconnect if available
                 if (typeof client.pb.ensureConnection === 'function') {
@@ -190,14 +191,14 @@ export const commands = [
                     }
 
                     if (!hangarSync) {
-						client.logger.info(`No sync data found for guild ${interaction.guildId}`);
+                        client.logger.info(`[cmd:hangarstatus] No sync data found for guild ${interaction.guildId}`);
                         return interaction.reply({
                             content: 'No sync data found. Please use `/hangarsync` first to establish a reference point.',
                             ephemeral: true
                         });
                     }
                 } catch (error) {
-					client.logger.info(`Error retrieving sync data for guild ${interaction.guildId}: ${error.message}`);
+                    client.logger.error(`[cmd:hangarstatus] Error retrieving sync data for guild ${interaction.guildId}: ${error.message}`);
                     return interaction.reply({
                         content: 'No sync data found. Please use `/hangarsync` first to establish a reference point.',
                         ephemeral: true
@@ -211,8 +212,8 @@ export const commands = [
 
                 // Key positions in the cycle
                 const allOffDuration = 5;
-				const turningGreenDuration = 5 * 24;
+                const _turningGreenDuration = 5 * 24 * 1000;
-				const turningOffDuration = 5 * 12;
+                const turningOffDuration = 5 * 12 * 1000;
 
                 // Calculate how much time has passed since the epoch
                 const timeSinceEpoch = (currentTime - hangarSync.epoch) / (60 * 1000);
@@ -221,26 +222,26 @@ export const commands = [
                 const cyclePosition = ((timeSinceEpoch % cycleDuration) + cycleDuration) % cycleDuration;
 
                 // Initialize stuff and things
-				const lights = [":black_circle:", ":black_circle:", ":black_circle:", ":black_circle:", ":black_circle:"];
+                const lights = [':black_circle:', ':black_circle:', ':black_circle:', ':black_circle:', ':black_circle:'];
                 let minutesUntilNextPhase = 0;
-				let currentPhase = "";
+                let currentPhase = '';
 
                 // If the epoch is now, we should be at the all-green position.
                 // From there, we need to determine where we are in the cycle.
 
                 // Case 1: We're in the unlocked phase, right after epoch
                 if (cyclePosition < turningOffDuration) {
-					currentPhase = "Unlocked";
+                    currentPhase = 'Unlocked';
 
                     // All lights start as green
-					lights.fill(":green_circle:");
+                    lights.fill(':green_circle:');
 
                     // Calculate how many lights have turned off
                     const offLights = Math.floor(cyclePosition / 12);
 
                     // Set the appropriate number of lights to off
                     for (let i = 0; i < offLights; i++) {
-						lights[i] = ":black_circle:";
+                        lights[i] = ':black_circle:';
                     }
 
                     // Calculate time until next light turns off
@@ -250,7 +251,7 @@ export const commands = [
 
                 // Case 2: We're in the reset phase
                 else if (cyclePosition < turningOffDuration + allOffDuration) {
-					currentPhase = "Resetting";
+                    currentPhase = 'Resetting';
 
                     // Lights are initialized "off", so do nothing with them
 
@@ -261,10 +262,10 @@ export const commands = [
 
                 // Case 3: We're in the locked phase
                 else {
-					currentPhase = "Locked";
+                    currentPhase = 'Locked';
 
                     // All lights start as red
-					lights.fill(":red_circle:");
+                    lights.fill(':red_circle:');
 
                     // Calculate how many lights have turned green
                     const timeIntoPhase = cyclePosition - (turningOffDuration + allOffDuration);
@@ -272,7 +273,7 @@ export const commands = [
 
                     // Set the appropriate number of lights to green
                     for (let i = 0; i < greenLights; i++) {
-						lights[i] = ":green_circle:";
+                        lights[i] = ':green_circle:';
                     }
 
                     // Calculate time until next light turns green
@@ -322,7 +323,7 @@ export const commands = [
             } catch (error) {
                 client.logger.error(`Error in hangarstatus command: ${error.message}`);
                 await interaction.reply({
-					content: `Error retrieving hangar status. Please try again later.`,
+                    content: 'Error retrieving hangar status. Please try again later.',
                     ephemeral: true
                 });
             }
@@ -344,7 +345,7 @@ function isPocketBaseConnected(client) {
 }
 
 // Initialize module
-export const init = async (client, config) => {
+export async function init(client, _config) {
     client.logger.info('Initializing Star Citizen Hangar Status module');
 
     // Check PocketBase connection
@@ -360,4 +361,4 @@ export const init = async (client, config) => {
     }
 
     client.logger.info('Star Citizen Hangar Status module initialized');
-};
+}

_opt/scorekeeper-example.js

@@ -1,5 +1,5 @@
 // Example of another module using scorekeeper
-export const init = async (client, config) => {
+export async function init(client, _config) {
     // Set up message listener that adds input points when users chat
     client.on('messageCreate', async (message) => {
         if (message.author.bot) return;
@@ -14,7 +14,7 @@ export const init = async (client, config) => {
         // Do not award zero or negative points
         if (points <= 0) return;
         try {
-			await client.scorekeeper.addInput(message.guild.id, message.author.id, points);
+            await client.scorekeeper.addInput(message.guild.id, message.author.id, points, 'message');
         } catch (error) {
             client.logger.error(`Error adding input points: ${error.message}`);
         }
@@ -76,7 +76,7 @@ export const init = async (client, config) => {
         // If someone joined or left a channel, update tracking for everyone in that channel
         updateChannelUserTracking(client, oldState, newState);
     });
-};
+}
 
 /**
  * Process when a user leaves a voice channel
@@ -92,7 +92,7 @@ function processVoiceLeave(client, guild, member, channelId) {
             const points = Math.min(Math.floor(duration), 30);
             if (points > 0) {
                 try {
-					client.scorekeeper.addInput(guild.id, member.id, points)
+                    client.scorekeeper.addInput(guild.id, member.id, points, 'voice_activity')
                         .then(() => {
                             client.logger.debug(`Added ${points} voice activity points for ${member.user.tag}`);
                         })

_opt/scorekeeper.js

@@ -1,17 +1,18 @@
+import { MessageFlags } from 'discord-api-types/v10';
 // opt/scorekeeper.js
-import cron from 'node-cron';
 import { SlashCommandBuilder, EmbedBuilder, PermissionFlagsBits } from 'discord.js';
+import cron from 'node-cron';
 
 // Module state container
 const moduleState = {
-	cronJobs: new Map(), // Store cron jobs by client ID
+    cronJobs: new Map() // Store cron jobs by client ID
 };
 
 /**
  * Initialize the scorekeeper module
  */
 export const init = async (client, config) => {
-	client.logger.info('Initializing Scorekeeper module');
+    client.logger.info('[module:scorekeeper] Initializing Scorekeeper module');
 
     // Check if configuration exists
     if (!config.scorekeeper) {
@@ -33,8 +34,22 @@ export const init = async (client, config) => {
     await checkEventsCollection(client);
     // Create scorekeeper interface on client
     client.scorekeeper = {
-		addInput: (guildId, userId, amount) => addInput(client, guildId, userId, amount),
+        /**
-		addOutput: (guildId, userId, amount) => addOutput(client, guildId, userId, amount),
+        * Add input points with optional reason for audit
+        * @param {string} guildId
+        * @param {string} userId
+        * @param {number} amount
+        * @param {string} [reason]
+        */
+        addInput: (guildId, userId, amount, reason) => addInput(client, guildId, userId, amount, reason),
+        /**
+        * Add output points with optional reason for audit
+        * @param {string} guildId
+        * @param {string} userId
+        * @param {number} amount
+        * @param {string} [reason]
+        */
+        addOutput: (guildId, userId, amount, reason) => addOutput(client, guildId, userId, amount, reason),
         addCommendation: (guildId, userId, amount = 1) => addCommendation(client, guildId, userId, amount),
         addCitation: (guildId, userId, amount = 1) => addCitation(client, guildId, userId, amount),
         getScore: (guildId, userId) => getScore(client, guildId, userId),
@@ -57,10 +72,10 @@ async function checkCollection(client) {
     try {
         // Check if collection exists by trying to list records
         await client.pb.collection('scorekeeper').getList(1, 1);
-		client.logger.info('Scorekeeper collection exists in PocketBase');
+        client.logger.info('[module:scorekeeper] Scorekeeper collection exists in PocketBase');
     } catch (error) {
         // If collection doesn't exist, log warning
-		client.logger.warn('Scorekeeper collection does not exist in PocketBase');
+        client.logger.warn('[module:scorekeeper] Scorekeeper collection does not exist in PocketBase');
         client.logger.warn('Please create a "scorekeeper" collection with fields:');
         client.logger.warn('- guildId (text, required)');
         client.logger.warn('- userId (text, required)');
@@ -79,9 +94,9 @@ async function checkCollection(client) {
 async function checkCategoriesCollection(client) {
     try {
         await client.pb.collection('scorekeeper_categories').getList(1, 1);
-    client.logger.info('scorekeeper_categories collection exists');
+        client.logger.info('[module:scorekeeper] scorekeeper_categories collection exists');
     } catch (error) {
-    client.logger.warn('scorekeeper_categories collection does not exist in PocketBase');
+        client.logger.warn('[module:scorekeeper] scorekeeper_categories collection does not exist in PocketBase');
         client.logger.warn('Please create a "scorekeeper_categories" collection with fields:');
         client.logger.warn('- guildId (text, required)');
         client.logger.warn('- name (text, required, unique per guild)');
@@ -98,9 +113,9 @@ async function checkCategoriesCollection(client) {
 async function checkEventsCollection(client) {
     try {
         await client.pb.collection('scorekeeper_events').getList(1, 1);
-    client.logger.info('scorekeeper_events collection exists');
+        client.logger.info('[module:scorekeeper] scorekeeper_events collection exists');
     } catch (error) {
-    client.logger.warn('scorekeeper_events collection does not exist in PocketBase');
+        client.logger.warn('[module:scorekeeper] scorekeeper_events collection does not exist in PocketBase');
         client.logger.warn('Please create a "scorekeeper_events" collection with fields:');
         client.logger.warn('- guildId (text, required)');
         client.logger.warn('- userId (text, required)');
@@ -154,7 +169,15 @@ function setupDecayCron(client, schedule) {
 /**
  * Add input points for a user
  */
-async function addInput(client, guildId, userId, amount) {
+/**
+ * Add input points for a user and log an audit event
+ * @param {import('discord.js').Client} client
+ * @param {string} guildId
+ * @param {string} userId
+ * @param {number} amount
+ * @param {string} [reason]
+ */
+async function addInput(client, guildId, userId, amount, reason = '') {
     if (!guildId || !userId || !amount || amount <= 0) {
         throw new Error(`Invalid parameters for addInput - guildId: ${guildId}, userId: ${userId}, amount: ${amount}`);
     }
@@ -169,9 +192,25 @@ async function addInput(client, guildId, userId, amount) {
         client.logger.debug(`Updating record ${scoreData.id} - input from ${scoreData.input} to ${newInput}`);
 
         // Use direct update with ID to avoid duplicate records
-		return await client.pb.collection('scorekeeper').update(scoreData.id, {
+        const updatedRecord = await client.pb.collection('scorekeeper').update(scoreData.id, {
             input: newInput
         });
+        // Log input change at info level
+        client.logger.info(`[module:scorekeeper][addInput] guildId=${guildId}, userId=${userId}, recordId=${scoreData.id}, previousInput=${scoreData.input}, newInput=${newInput}, amount=${amount}, reason=${reason}`);
+        // Audit event: log input change
+        try {
+            await client.pb.collection('scorekeeper_events').create({
+                guildId,
+                userId,
+                type: 'input',
+                amount,
+                reason,
+                awardedBy: client.user?.id
+            });
+        } catch (eventError) {
+            client.logger.error(`[module:scorekeeper] Failed to log input event: ${eventError.message}`);
+        }
+        return updatedRecord;
     } catch (error) {
         client.logger.error(`Error adding input points: ${error.message}`);
         throw error;
@@ -181,7 +220,15 @@ async function addInput(client, guildId, userId, amount) {
 /**
  * Add output points for a user
  */
-async function addOutput(client, guildId, userId, amount) {
+/**
+ * Add output points for a user and log an audit event
+ * @param {import('discord.js').Client} client
+ * @param {string} guildId
+ * @param {string} userId
+ * @param {number} amount
+ * @param {string} [reason]
+ */
+async function addOutput(client, guildId, userId, amount, reason = '') {
     if (!guildId || !userId || !amount || amount <= 0) {
         throw new Error('Invalid parameters for addOutput');
     }
@@ -196,9 +243,25 @@ async function addOutput(client, guildId, userId, amount) {
         client.logger.debug(`Updating record ${scoreData.id} - output from ${scoreData.output} to ${newOutput}`);
 
         // Use direct update with ID to avoid duplicate records
-		return await client.pb.collection('scorekeeper').update(scoreData.id, {
+        const updatedRecord = await client.pb.collection('scorekeeper').update(scoreData.id, {
             output: newOutput
         });
+        // Log output change at info level
+        client.logger.info(`[module:scorekeeper][addOutput] guildId=${guildId}, userId=${userId}, recordId=${scoreData.id}, previousOutput=${scoreData.output}, newOutput=${newOutput}, amount=${amount}, reason=${reason}`);
+        // Audit event: log output change
+        try {
+            await client.pb.collection('scorekeeper_events').create({
+                guildId,
+                userId,
+                type: 'output',
+                amount,
+                reason,
+                awardedBy: client.user?.id
+            });
+        } catch (eventError) {
+            client.logger.error(`[module:scorekeeper] Failed to log output event: ${eventError.message}`);
+        }
+        return updatedRecord;
     } catch (error) {
         client.logger.error(`Error adding output points: ${error.message}`);
         throw error;
@@ -372,7 +435,8 @@ async function runDecay(client, guildId) {
             }
         }
 
-		client.logger.info(`Decay completed for guild ${guildId}: ${updatedCount} records updated`);
+        const _reason = 'Automated decay';
+        client.logger.info(`[module:scorekeeper] Decayed ${updatedCount} records by ${client.config.scorekeeper.decay}% (${_reason})`);
         return updatedCount;
     } catch (error) {
         client.logger.error(`Error running decay: ${error.message}`);
@@ -460,6 +524,9 @@ export const commands = [
         execute: async (interaction, client) => {
             const targetUser = interaction.options.getUser('user') || interaction.user;
             const ephemeral = interaction.options.getBoolean('ephemeral') ?? true;
+            // Acknowledge early to avoid interaction timeout
+            await interaction.deferReply({ ephemeral });
+            client.logger.info(`[cmd:score] Processing score for user ${targetUser.id}`);
             // Wrap score retrieval and embed generation in try/catch to handle errors gracefully
             try {
 
@@ -474,30 +541,59 @@ export const commands = [
                     filter: `guildId = "${interaction.guildId}"`
                 });
                 const catMap = new Map(categories.map(c => [c.id, c.name]));
-            // Commendations per category
+                // Commendations grouped by category with reasons
                 const commendEvents = await client.pb.collection('scorekeeper_events').getFullList({
                     filter: `guildId = "${interaction.guildId}" && userId = "${targetUser.id}" && type = "commendation"`
                 });
-            const commendByCat = new Map();
+                let commendBreakdown = 'None';
-            commendEvents.forEach(e => {
+                if (commendEvents.length > 0) {
-                const cnt = commendByCat.get(e.categoryId) || 0;
+                // Group events by category
-                commendByCat.set(e.categoryId, cnt + e.amount);
+                    const eventsByCat = new Map();
-            });
+                    for (const e of commendEvents) {
-            const commendBreakdown = commendByCat.size > 0
+                        const arr = eventsByCat.get(e.categoryId) || [];
-                ? Array.from(commendByCat.entries()).map(([cid, cnt]) => `${catMap.get(cid) || 'Unknown'}: ${cnt}`).join('\n')
+                        arr.push(e);
-                : 'None';
+                        eventsByCat.set(e.categoryId, arr);
-            // Citations per category
+                    }
+                    // Build breakdown string
+                    const parts = [];
+                    for (const [cid, events] of eventsByCat.entries()) {
+                        const catName = catMap.get(cid) || 'Unknown';
+                        parts.push(`__${catName}__`);
+                        // List each event as bullet with date and reason
+                        for (const ev of events) {
+                            const date = new Date(ev.created || ev.timestamp);
+                            const shortDate = date.toLocaleDateString();
+                            const reason = ev.reason || '';
+                            parts.push(`• ${shortDate}: ${reason}`);
+                        }
+                    }
+                    commendBreakdown = parts.join('\n');
+                }
+                // Citations grouped by category with reasons
                 const citeEvents = await client.pb.collection('scorekeeper_events').getFullList({
                     filter: `guildId = "${interaction.guildId}" && userId = "${targetUser.id}" && type = "citation"`
                 });
-            const citeByCat = new Map();
+                let citeBreakdown = 'None';
-            citeEvents.forEach(e => {
+                if (citeEvents.length > 0) {
-                const cnt = citeByCat.get(e.categoryId) || 0;
+                    const eventsByCat2 = new Map();
-                citeByCat.set(e.categoryId, cnt + e.amount);
+                    for (const e of citeEvents) {
-            });
+                        const arr = eventsByCat2.get(e.categoryId) || [];
-            const citeBreakdown = citeByCat.size > 0
+                        arr.push(e);
-                ? Array.from(citeByCat.entries()).map(([cid, cnt]) => `${catMap.get(cid) || 'Unknown'}: ${cnt}`).join('\n')
+                        eventsByCat2.set(e.categoryId, arr);
-                : 'None';
+                    }
+                    const parts2 = [];
+                    for (const [cid, events] of eventsByCat2.entries()) {
+                        const catName = catMap.get(cid) || 'Unknown';
+                        parts2.push(`__${catName}__`);
+                        for (const ev of events) {
+                            const date = new Date(ev.created || ev.timestamp);
+                            const shortDate = date.toLocaleDateString();
+                            const reason = ev.reason || '';
+                            parts2.push(`• ${shortDate}: ${reason}`);
+                        }
+                    }
+                    citeBreakdown = parts2.join('\n');
+                }
                 const embed = new EmbedBuilder()
                     .setAuthor({ name: `${client.user.username}: Scorekeeper Module`, iconURL: client.user.displayAvatarURL() })
                     .setTitle(`I/O Score for ${(await interaction.guild.members.fetch(targetUser.id).catch(() => null))?.displayName || targetUser.username}`)
@@ -514,16 +610,16 @@ export const commands = [
                         { name: 'Commendation Value', value: `-# ${commendationValue}`, inline: true },
                         { name: 'Citation Value', value: `-# ${citationValue}`, inline: true },
                         { name: 'Multiplier Formula', value: `-# 1 + (${scoreData.commendations} * ${commendationValue}) - (${scoreData.citations} * ${citationValue}) = ${multiplierValue.toFixed(2)}`, inline: false },
-                { name: 'Priority Score Formula', value: `-# ${multiplierValue.toFixed(2)} × ${scoreData.input} / (${scoreData.output} + ${baseOutput}) = ${scoreData.totalScore.toFixed(2)}`, inline: false },
+                        { name: 'Priority Score Formula', value: `-# ${multiplierValue.toFixed(2)} × ${scoreData.input} / (${scoreData.output} + ${baseOutput}) = ${scoreData.totalScore.toFixed(2)}`, inline: false }
                     )
                     .setFooter({ text: 'Last decay: ' + new Date(scoreData.lastDecay).toLocaleDateString() })
                     .setTimestamp();
 
-                await interaction.reply({ embeds: [embed], ephemeral });
+                await interaction.editReply({ embeds: [embed] });
             } catch (error) {
-                client.logger.error(`Error in score command: ${error.message}`);
+                client.logger.error(`[cmd:score] Error: ${error.message}`);
                 try {
-                    await interaction.reply({ content: 'Failed to retrieve I/O score.', ephemeral });
+                    await interaction.editReply({ content: 'Failed to retrieve I/O score.' });
                 } catch {}
             }
         }
@@ -596,6 +692,11 @@ export const commands = [
                     .setRequired(true)
                     .setAutocomplete(true)
             )
+            .addStringOption(option =>
+                option.setName('reason')
+                    .setDescription('Reason for commendation')
+                    .setRequired(true)
+            )
             .setDefaultMemberPermissions(PermissionFlagsBits.Administrator),
 
         execute: async (interaction, client) => {
@@ -615,12 +716,13 @@ export const commands = [
             }
             const targetUser = interaction.options.getUser('user');
             const categoryId = interaction.options.getString('category');
+            const reason = interaction.options.getString('reason');
             const amount = 1;
             // Enforce per-category cooldown
             const cooldown = client.config.scorekeeper.cooldown || 0;
             if (cooldown > 0) {
                 const recent = await client.pb.collection('scorekeeper_events').getList(1, 1, {
-                                    filter: `guildId = \"${guildId}\" && userId = \"${targetUser.id}\" && type = \"commendation\" && categoryId = \"${categoryId}\"`,
+                    filter: `guildId = "${guildId}" && userId = "${targetUser.id}" && type = "commendation" && categoryId = "${categoryId}"`,
                     sort: '-created'
                 });
                 const lastItem = recent.items?.[0];
@@ -650,9 +752,11 @@ export const commands = [
                     type: 'commendation',
                     categoryId,
                     amount,
+                    reason,
                     awardedBy: interaction.user.id
                 });
 
+                client.logger.info(`[cmd:commend] Added commendation to ${targetUser.id} in category ${categoryId} with reason: ${reason}`);
                 await interaction.reply(`Added commendation to ${targetUser}.`);
             } catch (error) {
                 client.logger.error(`Error in commend command: ${error.message}`);
@@ -679,6 +783,11 @@ export const commands = [
                     .setRequired(true)
                     .setAutocomplete(true)
             )
+            .addStringOption(option =>
+                option.setName('reason')
+                    .setDescription('Reason for citation')
+                    .setRequired(true)
+            )
             .setDefaultMemberPermissions(PermissionFlagsBits.Administrator),
 
         execute: async (interaction, client) => {
@@ -698,12 +807,13 @@ export const commands = [
             }
             const targetUser = interaction.options.getUser('user');
             const categoryId = interaction.options.getString('category');
+            const reason = interaction.options.getString('reason');
             const amount = 1;
             // Enforce per-category cooldown
             const cooldown = client.config.scorekeeper.cooldown || 0;
             if (cooldown > 0) {
                 const recent = await client.pb.collection('scorekeeper_events').getList(1, 1, {
-                                    filter: `guildId = \"${guildId}\" && userId = \"${targetUser.id}\" && type = \"citation\" && categoryId = \"${categoryId}\"`,
+                    filter: `guildId = "${guildId}" && userId = "${targetUser.id}" && type = "citation" && categoryId = "${categoryId}"`,
                     sort: '-created'
                 });
                 const lastItem = recent.items?.[0];
@@ -726,16 +836,17 @@ export const commands = [
             try {
                 await client.scorekeeper.addCitation(interaction.guildId, targetUser.id, amount);
                 // Log event
-                            // Log event (timestamp managed by PocketBase "created" field)
                 await client.pb.collection('scorekeeper_events').create({
                     guildId: interaction.guildId,
                     userId: targetUser.id,
                     type: 'citation',
                     categoryId,
                     amount,
+                    reason,
                     awardedBy: interaction.user.id
                 });
 
+                client.logger.info(`[cmd:cite] Added citation to ${targetUser.id} in category ${categoryId} with reason: ${reason}`);
                 await interaction.reply(`Added citation to ${targetUser}.`);
             } catch (error) {
                 client.logger.error(`Error in cite command: ${error.message}`);
@@ -799,7 +910,7 @@ export const commands = [
                 await interaction.reply({ content: `Category '${name}' created.`, ephemeral: true });
             } catch (err) {
                 client.logger.error(`Error in addcategory: ${err.message}`);
-        await interaction.reply({ content: 'Failed to create category.', ephemeral: true });
+                await interaction.reply({ content: 'Failed to create category.', flags: MessageFlags.Ephemeral });
             }
         }
     }
@@ -828,15 +939,16 @@ export const commands = [
                 await interaction.reply({ content: `Category '${name}' removed.`, ephemeral: true });
             } catch (err) {
                 client.logger.error(`Error in removecategory: ${err.message}`);
-        await interaction.reply({ content: 'Failed to remove category.', ephemeral: true });
+                await interaction.reply({ content: 'Failed to remove category.', flags: MessageFlags.Ephemeral });
             }
         }
     }
-  // Public command: list categories
+    // Public command: list categories (admin-only)
     ,{
         data: new SlashCommandBuilder()
             .setName('listcategories')
-      .setDescription('List all commendation/citation categories')
+            .setDescription('List all commendation/citation categories (Admin only)')
+            .setDefaultMemberPermissions(PermissionFlagsBits.Administrator)
             .addBooleanOption(opt =>
                 opt.setName('ephemeral')
                     .setDescription('Whether the result should be ephemeral')

_opt/tempvc.js

@@ -0,0 +1,677 @@
+import { MessageFlags } from 'discord-api-types/v10';
+import { SlashCommandBuilder, PermissionFlagsBits, ChannelType, EmbedBuilder } from 'discord.js';
+// Init function to handle autocomplete for /vc invite
+/**
+ * tempvc module: temporary voice channel manager
+ *
+ * Admin commands (/vcadmin):
+ *   - add <voice_channel> <category>
+ *   - remove <voice_channel>
+ *   - list
+ *
+ * User commands (/vc):
+ *   Access Control:
+ *     • invite <user>
+ *     • kick <user>
+ *     • role <role>
+ *     • mode <whitelist|blacklist>
+ *     • limit <0-99>
+ *   Presets:
+ *     • save <name>
+ *     • restore <name>
+ *     • reset
+ *   Utilities:
+ *     • rename <new_name>
+ *     • info
+ *     • delete
+ *
+ * PocketBase collections required:
+ *   tempvc_masters (guildId, masterChannelId, categoryId)
+ *   tempvc_sessions (guildId, masterChannelId, channelId, ownerId, roleId, mode)
+ *   tempvc_presets  (guildId, userId, name, channelName, userLimit, roleId, invitedUserIds, mode)
+ */
+
+// Temporary Voice Channel module
+// - /vcadmin: admin commands to add/remove/list spawn channels
+// - /vc: user commands to manage own temp VC, presets save/restore
+
+/**
+ * Slash commands for vcadmin and vc
+ */
+export const commands = [
+    // Administrator: manage spawn points
+    {
+        data: new SlashCommandBuilder()
+            .setName('vcadmin')
+            .setDescription('Configure temporary voice-channel spawn points (Admin only)')
+            .setDefaultMemberPermissions(PermissionFlagsBits.Administrator)
+            .setDMPermission(false)
+            .addSubcommand(sub =>
+                sub.setName('add')
+                    .setDescription('Add a spawn voice channel and its temp category')
+                    .addChannelOption(opt =>
+                        opt.setName('voice_channel')
+                            .setDescription('Voice channel to spawn from')
+                            .setRequired(true)
+                            .addChannelTypes(ChannelType.GuildVoice)
+                    )
+                    .addChannelOption(opt =>
+                        opt.setName('category')
+                            .setDescription('Category for new temp channels')
+                            .setRequired(true)
+                            .addChannelTypes(ChannelType.GuildCategory)
+                    )
+            )
+            .addSubcommand(sub =>
+                sub.setName('remove')
+                    .setDescription('Remove a spawn voice channel')
+                    .addChannelOption(opt =>
+                        opt.setName('voice_channel')
+                            .setDescription('Voice channel to remove')
+                            .setRequired(true)
+                            .addChannelTypes(ChannelType.GuildVoice)
+                    )
+            )
+            .addSubcommand(sub =>
+                sub.setName('list')
+                    .setDescription('List all spawn voice channels and categories')
+            ),
+        async execute(interaction, client) {
+            const guildId = interaction.guildId;
+            const sub = interaction.options.getSubcommand();
+            // ensure in-guild
+            if (!guildId) {
+                return interaction.reply({ content: 'This command can only be used in a server.', flags: MessageFlags.Ephemeral });
+            }
+            // init memory map for this guild
+            client.tempvc = client.tempvc || { masters: new Map(), sessions: new Map() };
+            if (!client.tempvc.masters.has(guildId)) {
+                client.tempvc.masters.set(guildId, new Map());
+            }
+            const guildMasters = client.tempvc.masters.get(guildId);
+            try {
+                if (sub === 'add') {
+                    const vc = interaction.options.getChannel('voice_channel', true);
+                    const cat = interaction.options.getChannel('category', true);
+                    // persist
+                    const existing = await client.pb.getFirst(
+                        'tempvc_masters',
+                        `guildId = "${guildId}" && masterChannelId = "${vc.id}"`
+                    );
+                    if (existing) {
+                        await client.pb.updateOne('tempvc_masters', existing.id, {
+                            guildId, masterChannelId: vc.id, categoryId: cat.id
+                        });
+                    } else {
+                        await client.pb.createOne('tempvc_masters', {
+                            guildId, masterChannelId: vc.id, categoryId: cat.id
+                        });
+                    }
+                    // update memory
+                    guildMasters.set(vc.id, cat.id);
+                    await interaction.reply({
+                        content: `Spawn channel <#${vc.id}> will now create temp VCs in <#${cat.id}>.`,
+                        flags: MessageFlags.Ephemeral
+                    });
+                } else if (sub === 'remove') {
+                    const vc = interaction.options.getChannel('voice_channel', true);
+                    if (!guildMasters.has(vc.id)) {
+                        return interaction.reply({ content: 'That channel is not configured as a spawn point.', flags: MessageFlags.Ephemeral });
+                    }
+                    // remove from PB
+                    const existing = await client.pb.getFirst(
+                        'tempvc_masters',
+                        `guildId = "${guildId}" && masterChannelId = "${vc.id}"`
+                    );
+                    if (existing) {
+                        await client.pb.deleteOne('tempvc_masters', existing.id);
+                    }
+                    // update memory
+                    guildMasters.delete(vc.id);
+                    await interaction.reply({ content: `Removed spawn channel <#${vc.id}>.`, flags: MessageFlags.Ephemeral });
+                } else if (sub === 'list') {
+                    if (guildMasters.size === 0) {
+                        return interaction.reply({ content: 'No spawn channels configured.', flags: MessageFlags.Ephemeral });
+                    }
+                    const lines = [];
+                    for (const [mId, cId] of guildMasters.entries()) {
+                        lines.push(`<#${mId}> → <#${cId}>`);
+                    }
+                    await interaction.reply({ content: '**Spawn channels:**\n' + lines.join('\n'), flags: MessageFlags.Ephemeral });
+                }
+            } catch (err) {
+                client.logger.error(`[module:tempvc][vcadmin] ${err.message}`);
+                await interaction.reply({ content: 'Operation failed, see logs.', flags: MessageFlags.Ephemeral });
+            }
+        }
+    },
+    // User: manage own temp VC and presets
+    {
+        data: new SlashCommandBuilder()
+            .setName('vc')
+            .setDescription('Manage your temporary voice channel')
+            .setDMPermission(false)
+        // Access Control
+            .addSubcommand(sub =>
+                sub.setName('invite')
+                    .setDescription('Invite a user to this channel')
+                // Autocomplete string option for user ID
+                    .addStringOption(opt =>
+                        opt.setName('user')
+                            .setDescription('User to invite')
+                            .setRequired(true)
+                            .setAutocomplete(true)
+                    )
+            )
+            .addSubcommand(sub =>
+                sub.setName('kick')
+                    .setDescription('Kick a user from this channel')
+                    .addUserOption(opt => opt.setName('user').setDescription('User to kick').setRequired(true))
+            )
+            .addSubcommand(sub =>
+                sub.setName('role')
+                    .setDescription('Set role to allow/deny access')
+                    .addRoleOption(opt => opt.setName('role').setDescription('Role to allow/deny').setRequired(true))
+            )
+            .addSubcommand(sub =>
+                sub.setName('mode')
+                    .setDescription('Switch role mode')
+                    .addStringOption(opt =>
+                        opt.setName('mode')
+                            .setDescription('Mode: whitelist or blacklist')
+                            .setRequired(true)
+                            .addChoices(
+                                { name: 'whitelist', value: 'whitelist' },
+                                { name: 'blacklist', value: 'blacklist' }
+                            )
+                    )
+            )
+            .addSubcommand(sub =>
+                sub.setName('limit')
+                    .setDescription('Set user limit (0–99)')
+                    .addIntegerOption(opt => opt.setName('number').setDescription('Max users').setRequired(true))
+            )
+        // Presets
+            .addSubcommand(sub =>
+                sub.setName('save')
+                    .setDescription('Save current settings as a preset')
+                    .addStringOption(opt => opt.setName('name').setDescription('Preset name').setRequired(true).setAutocomplete(true))
+            )
+            .addSubcommand(sub =>
+                sub.setName('restore')
+                    .setDescription('Restore settings from a preset')
+                    .addStringOption(opt => opt.setName('name').setDescription('Preset name').setRequired(true).setAutocomplete(true))
+            )
+            .addSubcommand(sub => sub.setName('reset').setDescription('Reset channel to default settings'))
+        // Utilities
+            .addSubcommand(sub => sub.setName('rename').setDescription('Rename this channel').addStringOption(opt => opt.setName('new_name').setDescription('New channel name').setRequired(true)))
+            .addSubcommand(sub => sub.setName('info').setDescription('Show channel info'))
+            .addSubcommand(sub => sub.setName('delete').setDescription('Delete this channel')),
+        async execute(interaction, client) {
+            const guild = interaction.guild;
+            const member = interaction.member;
+            const sub = interaction.options.getSubcommand();
+            // must be in guild and in voice
+            if (!guild || !member || !member.voice.channel) {
+                return interaction.reply({ content: 'You must be in a temp voice channel to use this.', flags: MessageFlags.Ephemeral });
+            }
+            const voice = member.voice.channel;
+            client.tempvc = client.tempvc || { masters: new Map(), sessions: new Map() };
+            const sess = client.tempvc.sessions.get(voice.id);
+            if (!sess) {
+                return interaction.reply({ content: 'This is not one of my temporary channels.', flags: MessageFlags.Ephemeral });
+            }
+            if (sess.ownerId !== interaction.user.id) {
+                return interaction.reply({ content: 'Only the room owner can do that.', flags: MessageFlags.Ephemeral });
+            }
+            try {
+                if (sub === 'rename') {
+                    const name = interaction.options.getString('new_name', true);
+                    await voice.setName(name);
+                    await interaction.reply({ content: `Channel renamed to **${name}**.`, flags: MessageFlags.Ephemeral });
+                } else if (sub === 'invite') {
+                    // Invitation: support both string (autocomplete) and user option types
+                    let userId;
+                    let memberToInvite;
+                    // Try string option first (autocomplete)
+                    try {
+                        userId = interaction.options.getString('user', true);
+                        memberToInvite = await guild.members.fetch(userId);
+                    } catch (e) {
+                        // Fallback to user option
+                        try {
+                            const user = interaction.options.getUser('user', true);
+                            userId = user.id;
+                            memberToInvite = await guild.members.fetch(userId);
+                        } catch {
+                            memberToInvite = null;
+                        }
+                    }
+                    if (!memberToInvite) {
+                        return interaction.reply({ content: 'User not found in this server.', flags: MessageFlags.Ephemeral });
+                    }
+                    // grant view and connect
+                    await voice.permissionOverwrites.edit(userId, { ViewChannel: true, Connect: true });
+                    await interaction.reply({ content: `Invited <@${userId}>.`, flags: MessageFlags.Ephemeral });
+                } else if (sub === 'kick') {
+                    const u = interaction.options.getUser('user', true);
+                    const gm = await guild.members.fetch(u.id);
+                    // move them out if in this channel
+                    if (gm.voice.channelId === voice.id) {
+                        await gm.voice.setChannel(null);
+                    }
+                    // remove any previous invite allow
+                    try {
+                        await voice.permissionOverwrites.delete(u.id);
+                    } catch {}
+                    await interaction.reply({ content: `Kicked <@${u.id}>.`, flags: MessageFlags.Ephemeral });
+                } else if (sub === 'limit') {
+                    const num = interaction.options.getInteger('number', true);
+                    // enforce range 0-99
+                    if (num < 0 || num > 99) {
+                        return interaction.reply({ content: 'User limit must be between 0 (no limit) and 99.', flags: MessageFlags.Ephemeral });
+                    }
+                    await voice.setUserLimit(num);
+                    await interaction.reply({ content: `User limit set to ${num}.`, flags: MessageFlags.Ephemeral });
+                } else if (sub === 'role') {
+                    const newRole = interaction.options.getRole('role', true);
+                    const oldRoleId = sess.roleId;
+                    // remove old role overwrite if any
+                    if (oldRoleId && oldRoleId !== guild.roles.everyone.id) {
+                        await voice.permissionOverwrites.delete(oldRoleId).catch(() => {});
+                    }
+                    // selecting @everyone resets all
+                    if (newRole.id === guild.roles.everyone.id) {
+                        // clear all overwrites
+                        await voice.permissionOverwrites.set([
+                            { id: guild.roles.everyone.id, allow: [PermissionFlagsBits.Connect] },
+                            { id: sess.ownerId, allow: [PermissionFlagsBits.Connect, PermissionFlagsBits.MoveMembers, PermissionFlagsBits.ManageChannels] }
+                        ]);
+                        sess.roleId = '';
+                        await client.pb.updateOne('tempvc_sessions', sess.pbId, { roleId: '', mode: sess.mode });
+                        return interaction.reply({ content: '@everyone can now connect.', flags: MessageFlags.Ephemeral });
+                    }
+                    if (sess.mode === 'whitelist') {
+                        // whitelist: lock everyone, allow role
+                        await voice.permissionOverwrites.edit(guild.roles.everyone.id, { Connect: false });
+                        await voice.permissionOverwrites.edit(newRole.id, { Connect: true });
+                        sess.roleId = newRole.id;
+                        await client.pb.updateOne('tempvc_sessions', sess.pbId, { roleId: newRole.id, mode: sess.mode });
+                        await interaction.reply({ content: `Whitelisted role <@&${newRole.id}>.`, flags: MessageFlags.Ephemeral });
+                    } else {
+                        // blacklist: allow everyone, deny role
+                        await voice.permissionOverwrites.edit(guild.roles.everyone.id, { Connect: true });
+                        await voice.permissionOverwrites.edit(newRole.id, { Connect: false });
+                        sess.roleId = newRole.id;
+                        await client.pb.updateOne('tempvc_sessions', sess.pbId, { roleId: newRole.id, mode: sess.mode });
+                        await interaction.reply({ content: `Blacklisted role <@&${newRole.id}>.`, flags: MessageFlags.Ephemeral });
+                    }
+                } else if (sub === 'delete') {
+                    await interaction.reply({ content: 'Deleting your channel...', flags: MessageFlags.Ephemeral });
+                    await client.pb.deleteOne('tempvc_sessions', sess.pbId);
+                    client.tempvc.sessions.delete(voice.id);
+                    await voice.delete('Owner deleted temp VC');
+                } else if (sub === 'info') {
+                    const invites = voice.permissionOverwrites.cache
+                        .filter(po => po.allow.has(PermissionFlagsBits.Connect) && ![guild.roles.everyone.id, sess.roleId].includes(po.id))
+                        .map(po => `<@${po.id}>`);
+                    const everyoneId = guild.roles.everyone.id;
+                    const roleLine = (!sess.roleId || sess.roleId === everyoneId)
+                        ? '@everyone'
+                        : `<@&${sess.roleId}>`;
+                    const modeLine = sess.mode || 'whitelist';
+                    const lines = [
+                        `Owner: <@${sess.ownerId}>`,
+                        `Name: ${voice.name}`,
+                        `Role: ${roleLine} (${modeLine})`,
+                        `User limit: ${voice.userLimit}`,
+                        `Invites: ${invites.length ? invites.join(', ') : 'none'}`
+                    ];
+                    await interaction.reply({ content: lines.join('\n'), flags: MessageFlags.Ephemeral });
+                } else if (sub === 'save') {
+                    const name = interaction.options.getString('name', true);
+                    // gather invites
+                    const invited = voice.permissionOverwrites.cache
+                        .filter(po => po.allow.has(PermissionFlagsBits.Connect) && ![guild.roles.everyone.id, sess.roleId].includes(po.id))
+                        .map(po => po.id);
+                    // upsert preset
+                    const existing = await client.pb.getFirst(
+                        'tempvc_presets',
+                        `guildId = "${guild.id}" && userId = "${interaction.user.id}" && name = "${name}"`
+                    );
+                    const data = {
+                        guildId: guild.id,
+                        userId: interaction.user.id,
+                        name,
+                        channelName: voice.name,
+                        userLimit: voice.userLimit,
+                        roleId: sess.roleId || '',
+                        invitedUserIds: invited,
+                        mode: sess.mode || 'whitelist'
+                    };
+                    if (existing) {
+                        await client.pb.updateOne('tempvc_presets', existing.id, data);
+                    } else {
+                        await client.pb.createOne('tempvc_presets', data);
+                    }
+                    await interaction.reply({ content: `Preset **${name}** saved.`, flags: MessageFlags.Ephemeral });
+                } else if (sub === 'reset') {
+                    // Defer to avoid Discord interaction timeout during reset
+                    await interaction.deferReply({ flags: MessageFlags.Ephemeral });
+                    // reset channel to default parameters
+                    const owner = interaction.member;
+                    const display = owner.displayName || owner.user.username;
+                    const defaultName = `TempVC: ${display}`;
+                    await voice.setName(defaultName);
+                    await voice.setUserLimit(0);
+                    // clear all overwrites: allow everyone, owner elevated perms
+                    await voice.permissionOverwrites.set([
+                        { id: guild.roles.everyone.id, allow: [PermissionFlagsBits.ViewChannel, PermissionFlagsBits.Connect] },
+                        { id: sess.ownerId, allow: [
+                            PermissionFlagsBits.ViewChannel,
+                            PermissionFlagsBits.Connect,
+                            PermissionFlagsBits.MoveMembers,
+                            PermissionFlagsBits.ManageChannels,
+                            PermissionFlagsBits.PrioritySpeaker,
+                            PermissionFlagsBits.MuteMembers,
+                            PermissionFlagsBits.DeafenMembers
+                        ]
+                        }
+                    ]);
+                    sess.roleId = guild.roles.everyone.id;
+                    await client.pb.updateOne('tempvc_sessions', sess.pbId, { roleId: guild.roles.everyone.id, invitedUserIds: [] });
+                    await interaction.editReply({ content: 'Channel has been reset to default settings.' });
+                } else if (sub === 'mode') {
+                    const mode = interaction.options.getString('mode', true);
+                    sess.mode = mode;
+                    // apply mode overwrites
+                    if (mode === 'whitelist') {
+                        // only allow whitelisted role
+                        await voice.permissionOverwrites.edit(guild.roles.everyone.id, { ViewChannel: false });
+                        if (sess.roleId) await voice.permissionOverwrites.edit(sess.roleId, { ViewChannel: true });
+                    } else {
+                        // blacklist: allow everyone, then deny the specified role
+                        await voice.permissionOverwrites.edit(guild.roles.everyone.id, { ViewChannel: true });
+                        if (sess.roleId) await voice.permissionOverwrites.edit(sess.roleId, { ViewChannel: false });
+                    }
+                    // persist mode
+                    await client.pb.updateOne('tempvc_sessions', sess.pbId, { mode });
+                    await interaction.reply({ content: `Channel mode set to **${mode}**.`, flags: MessageFlags.Ephemeral });
+                } else if (sub === 'restore') {
+                    // Defer initial reply to extend Discord interaction window
+                    await interaction.deferReply({ flags: MessageFlags.Ephemeral });
+                    const name = interaction.options.getString('name', true);
+                    const preset = await client.pb.getFirst(
+                        'tempvc_presets',
+                        `guildId = "${guild.id}" && userId = "${interaction.user.id}" && name = "${name}"`
+                    );
+                    if (!preset) {
+                        return interaction.editReply({ content: `Preset **${name}** not found.` });
+                    }
+                    // apply settings
+                    await voice.setName(preset.channelName);
+                    await voice.setUserLimit(preset.userLimit);
+                    // apply mode-based permissions
+                    const mode = preset.mode || 'whitelist';
+                    sess.mode = mode;
+                    // adjust view/connect for @everyone
+                    await voice.permissionOverwrites.edit(
+                        guild.roles.everyone.id,
+                        { ViewChannel: mode === 'blacklist', Connect: mode === 'blacklist' }
+                    );
+                    // adjust view/connect for role
+                    if (preset.roleId) {
+                        await voice.permissionOverwrites.edit(
+                            preset.roleId,
+                            { ViewChannel: mode === 'whitelist', Connect: mode === 'whitelist' }
+                        );
+                    }
+                    // invite users explicitly
+                    for (const uid of preset.invitedUserIds || []) {
+                        await voice.permissionOverwrites.edit(uid, { Connect: true }).catch(() => {});
+                    }
+                    // persist session changes
+                    await client.pb.updateOne(
+                        'tempvc_sessions',
+                        sess.pbId,
+                        { roleId: preset.roleId || '', mode }
+                    );
+                    sess.roleId = preset.roleId || '';
+                    await interaction.editReply({ content: `Preset **${name}** restored (mode: ${mode}).` });
+                }
+            } catch (err) {
+                client.logger.error(`[module:tempvc][vc] ${err.message}`);
+                await interaction.reply({ content: 'Operation failed, see logs.', flags: MessageFlags.Ephemeral });
+            }
+        }
+    }
+];
+
+/**
+ * Initialize module: load PB state and hook events
+ */
+export async function init(client) {
+    // autocomplete for /vc invite
+    client.on('interactionCreate', async interaction => {
+        if (!interaction.isAutocomplete()) return;
+        if (interaction.commandName !== 'vc') return;
+        // Only handle autocomplete for the 'invite' subcommand
+        let sub;
+        try {
+            sub = interaction.options.getSubcommand();
+        } catch {
+            return;
+        }
+        if (sub !== 'invite') return;
+        const focused = interaction.options.getFocused();
+        const guild = interaction.guild;
+        if (!guild) return;
+        // Perform guild member search for autocomplete suggestions (prefix match)
+        let choices = [];
+        try {
+            const members = await guild.members.search({ query: focused, limit: 25 });
+            choices = members.map(m => ({ name: m.displayName || m.user.username, value: m.id }));
+        } catch (err) {
+            client.logger.error(`[module:tempvc] Autocomplete search failed: ${err.message}`);
+        }
+        // If no choices found or to support substring matching, fallback to cache filter
+        if (choices.length === 0) {
+            const str = String(focused).toLowerCase();
+            choices = Array.from(guild.members.cache.values())
+                .filter(m => (m.displayName || m.user.username).toLowerCase().includes(str))
+                .slice(0, 25)
+                .map(m => ({ name: m.displayName || m.user.username, value: m.id }));
+        }
+        // Respond with suggestions (max 25)
+        await interaction.respond(choices);
+    });
+    // tempvc state: masters per guild, sessions map
+    client.tempvc = { masters: new Map(), sessions: new Map() };
+    // hook voice state updates
+    client.on('voiceStateUpdate', async (oldState, newState) => {
+        client.logger.debug(
+            `[module:tempvc] voiceStateUpdate: user=${newState.id} oldChannel=${oldState.channelId} newChannel=${newState.channelId}`
+        );
+        // cleanup on leave
+        if (oldState.channelId && oldState.channelId !== newState.channelId) {
+            const sess = client.tempvc.sessions.get(oldState.channelId);
+            const ch = oldState.guild.channels.cache.get(oldState.channelId);
+            if (sess && (!ch || ch.members.size === 0)) {
+                await client.pb.deleteOne('tempvc_sessions', sess.pbId).catch(()=>{});
+                client.tempvc.sessions.delete(oldState.channelId);
+                await ch?.delete('Empty temp VC cleanup').catch(()=>{});
+            }
+        }
+        // spawn on join
+        if (newState.channelId && newState.channelId !== oldState.channelId) {
+            const masters = client.tempvc.masters.get(newState.guild.id) || new Map();
+            client.logger.debug(
+                `[module:tempvc] Guild ${newState.guild.id} masters: ${[...masters.keys()].join(',')}`
+            );
+            client.logger.debug(
+                `[module:tempvc] Checking spawn for channel ${newState.channelId}: ${masters.has(newState.channelId)}`
+            );
+            if (masters.has(newState.channelId)) {
+                const catId = masters.get(newState.channelId);
+                const owner = newState.member;
+                const guild = newState.guild;
+                // default channel name
+                const displayName = owner.displayName || owner.user.username;
+                const name = `TempVC: ${displayName}`;
+                // create channel
+                // create voice channel, default permissions inherited from category (allow everyone)
+                // create voice channel; default allow everyone view/join, owner elevated perms
+                const ch = await guild.channels.create({
+                    name,
+                    type: ChannelType.GuildVoice,
+                    parent: catId,
+                    permissionOverwrites: [
+                        { id: guild.roles.everyone.id, allow: [PermissionFlagsBits.ViewChannel, PermissionFlagsBits.Connect] },
+                        { id: owner.id, allow: [
+                            PermissionFlagsBits.ViewChannel,
+                            PermissionFlagsBits.Connect,
+                            PermissionFlagsBits.MoveMembers,
+                            PermissionFlagsBits.ManageChannels,
+                            PermissionFlagsBits.PrioritySpeaker,
+                            PermissionFlagsBits.MuteMembers,
+                            PermissionFlagsBits.DeafenMembers
+                        ]
+                        }
+                    ]
+                });
+                // move member
+                await owner.voice.setChannel(ch);
+                // persist session
+                const rec = await client.pb.createOne('tempvc_sessions', {
+                    guildId: guild.id,
+                    masterChannelId: newState.channelId,
+                    channelId: ch.id,
+                    ownerId: owner.id,
+                    roleId: guild.roles.everyone.id,
+                    mode: 'whitelist'
+                });
+                client.tempvc.sessions.set(ch.id, {
+                    pbId: rec.id,
+                    guildId: guild.id,
+                    masterChannelId: newState.channelId,
+                    ownerId: owner.id,
+                    roleId: guild.roles.everyone.id,
+                    mode: 'whitelist'
+                });
+                // send instructions to the voice channel itself
+                try {
+                    const helpEmbed = new EmbedBuilder()
+                        .setTitle('👋 Welcome to Your Temporary Voice Channel!')
+                        .setColor('Blue')
+                        .addFields(
+                            {
+                                name: 'Access Control',
+                                value:
+                  '• /vc invite <user> — Invite a user to this channel\n' +
+                  '• /vc kick <user> — Kick a user from this channel\n' +
+                  '• /vc role <role> — Set a role to allow/deny access\n' +
+                  '• /vc mode <whitelist|blacklist> — Switch role mode\n' +
+                  '• /vc limit <number> — Set user limit (0–99)'
+                            },
+                            {
+                                name: 'Presets',
+                                value:
+                  '• /vc save <name> — Save current settings as a preset\n' +
+                  '• /vc restore <name> — Restore settings from a preset\n' +
+                  '• /vc reset — Reset channel to default settings'
+                            },
+                            {
+                                name: 'Utilities',
+                                value:
+                  '• /vc rename <new_name> — Rename this channel\n' +
+                  '• /vc info — Show channel info\n' +
+                  '• /vc delete — Delete this channel'
+                            }
+                        );
+                    await ch.send({ embeds: [helpEmbed] });
+                } catch (err) {
+                    client.logger.error(`[module:tempvc] Error sending help message: ${err.message}`);
+                }
+            }
+        }
+    });
+    // autocomplete for /vc save & restore presets
+    client.on('interactionCreate', async interaction => {
+        if (!interaction.isAutocomplete() || interaction.commandName !== 'vc') return;
+        const sub = interaction.options.getSubcommand(false);
+        if (!['save', 'restore'].includes(sub)) return;
+        const focused = interaction.options.getFocused(true);
+        if (focused.name !== 'name') return;
+        const guildId = interaction.guildId;
+        const userId = interaction.user.id;
+        try {
+            const recs = await client.pb.getAll('tempvc_presets', {
+                filter: `guildId = "${guildId}" && userId = "${userId}"`
+            });
+            const choices = recs
+                .filter(r => r.name.toLowerCase().startsWith(focused.value.toLowerCase()))
+                .slice(0, 25)
+                .map(r => ({ name: r.name, value: r.name }));
+            await interaction.respond(choices);
+        } catch (err) {
+            client.logger.error(`[module:tempvc][autocomplete] ${err.message}`);
+            await interaction.respond([]);
+        }
+    });
+    // On ready: load masters/sessions, then check required permissions
+    client.on('ready', async () => {
+    // Load persistent spawn masters and active sessions
+        for (const guild of client.guilds.cache.values()) {
+            const gid = guild.id;
+            try {
+                const masters = await client.pb.getAll('tempvc_masters', { filter: `guildId = "${gid}"` }); // guildId = "X" works, but escaped quotes are allowed
+                const gm = new Map();
+                for (const rec of masters) gm.set(rec.masterChannelId, rec.categoryId);
+                client.tempvc.masters.set(gid, gm);
+                client.logger.info(`[module:tempvc] Loaded spawn masters for guild ${gid}: ${[...gm.keys()].join(', ')}`);
+            } catch (err) {
+                client.logger.error(`[module:tempvc] Error loading masters for guild ${gid}: ${err.message}`);
+            }
+            try {
+                const sessions = await client.pb.getAll('tempvc_sessions', { filter: `guildId = "${gid}"` });
+                for (const rec of sessions) {
+                    const ch = guild.channels.cache.get(rec.channelId);
+                    if (ch && ch.isVoiceBased()) {
+                        client.tempvc.sessions.set(rec.channelId, {
+                            pbId: rec.id,
+                            guildId: gid,
+                            masterChannelId: rec.masterChannelId,
+                            ownerId: rec.ownerId,
+                            roleId: rec.roleId || '',
+                            mode: rec.mode || 'whitelist'
+                        });
+                        if (rec.roleId) await ch.permissionOverwrites.edit(rec.roleId, { Connect: true }).catch(()=>{});
+                        await ch.permissionOverwrites.edit(rec.ownerId, { Connect: true, ManageChannels: true, MoveMembers: true });
+                    } else {
+                        await client.pb.deleteOne('tempvc_sessions', rec.id).catch(()=>{});
+                    }
+                }
+            } catch (err) {
+                client.logger.error(`[module:tempvc] Error loading sessions for guild ${gid}: ${err.message}`);
+            }
+        }
+        // Verify necessary permissions
+        for (const guild of client.guilds.cache.values()) {
+            // get bot's member in this guild
+            let me = guild.members.me;
+            if (!me) {
+                try { me = await guild.members.fetch(client.user.id); } catch { /* ignore */ }
+            }
+            if (!me) continue;
+            const missing = [];
+            if (!me.permissions.has(PermissionFlagsBits.ManageChannels)) missing.push('ManageChannels');
+            if (!me.permissions.has(PermissionFlagsBits.MoveMembers))    missing.push('MoveMembers');
+            if (missing.length) {
+                client.logger.warn(
+                    `[module:tempvc] Missing permissions in guild ${guild.id} (${guild.name}): ${missing.join(', ')}`
+                );
+            }
+        }
+    });
+    client.logger.info('[module:tempvc] Module initialized');
+}

_src/ansiColors.js

@@ -0,0 +1,90 @@
+// ANSI Colors helper - provides nested [tag]…[/] parsing and code-block wrapping.
+
+// ANSI color/style codes
+const CODES = {
+    // text colors
+    gray: 30, red: 31, green: 32, yellow: 33,
+    blue: 34, pink: 35, cyan: 36, white: 37,
+    // background colors
+    bgGray: 40, bgOrange: 41, bgBlue: 42,
+    bgTurquoise: 43, bgFirefly: 44, bgIndigo: 45,
+    bgLightGray: 46, bgWhite: 47,
+    // styles
+    bold: 1, underline: 4,
+    // reset
+    reset: 0
+};
+
+/**
+ * Escape literal brackets so users can write \[ and \] without triggering tags.
+ */
+export function escapeBrackets(str) {
+    return str
+        .replace(/\\\[/g, '__ESC_LB__')
+        .replace(/\\\]/g, '__ESC_RB__');
+}
+
+/** Restore any escaped brackets after formatting. */
+export function restoreBrackets(str) {
+    return str
+        .replace(/__ESC_LB__/g, '[')
+        .replace(/__ESC_RB__/g, ']');
+}
+
+/**
+ * Parse nested [tag1,tag2]…[/] patterns into ANSI codes (stack-based).
+ */
+export function formatAnsi(input) {
+    const stack = [];
+    let output = '';
+    const pattern = /\[\/\]|\[([^\]]+)\]/g;
+    let lastIndex = 0;
+    let match;
+
+    while ((match = pattern.exec(input)) !== null) {
+        output += input.slice(lastIndex, match.index);
+
+        if (match[0] === '[/]') {
+            if (stack.length) stack.pop();
+            output += `\u001b[${CODES.reset}m`;
+            for (const tag of stack) {
+                const code = CODES[tag] ?? CODES.gray;
+                output += `\u001b[${code}m`;
+            }
+        } else {
+            const tags = match[1].split(/[,;\s]+/).filter(Boolean);
+            for (const tag of tags) {
+                stack.push(tag);
+                const code = CODES[tag] ?? CODES.gray;
+                output += `\u001b[${code}m`;
+            }
+        }
+
+        lastIndex = pattern.lastIndex;
+    }
+
+    output += input.slice(lastIndex);
+    if (stack.length) output += `\u001b[${CODES.reset}m`;
+    return output;
+}
+
+/**
+ * Template-tag: ansi`[red]…[/] text`
+ * Escapes brackets, parses ANSI, and restores literals.
+ */
+export function ansi(strings, ...values) {
+    let built = '';
+    for (let i = 0; i < strings.length; i++) {
+        built += strings[i];
+        if (i < values.length) built += values[i];
+    }
+    return restoreBrackets(formatAnsi(escapeBrackets(built)));
+}
+
+/** Wrap text in a ```ansi code block for Discord. */
+export function wrapAnsi(text) {
+    return '```ansi\n' + text + '\n```';
+}
+
+// Export raw codes for advanced use (e.g., ansitheme module)
+export { CODES };

_src/loader.js

@@ -16,16 +16,20 @@ export const loadModules = async (clientConfig, client) => {
         fs.mkdirSync(modulesDir, { recursive: true });
     }
 
+    client.logger.info(`[module:loader] Loading modules: ${modules.join(', ')}`);
     // Load each module
     for (const moduleName of modules) {
         try {
-			const modulePath = path.join(modulesDir, `${moduleName}.js`);
+            // Try _opt first, then fallback to core _src modules
-
+            let modulePath = path.join(modulesDir, `${moduleName}.js`);
-			// Check if module exists
             if (!fs.existsSync(modulePath)) {
-				client.logger.warn(`Module not found: ${modulePath}`);
+                // Fallback to core source directory
+                modulePath = path.join(rootDir, '_src', `${moduleName}.js`);
+                if (!fs.existsSync(modulePath)) {
+                    client.logger.warn(`[module:loader] Module not found: ${moduleName}.js`);
                     continue;
                 }
+            }
 
             // Import module (using dynamic import for ES modules)
             // Import module
@@ -40,7 +44,7 @@ export const loadModules = async (clientConfig, client) => {
                         if (command.data && typeof command.execute === 'function') {
                             const commandName = command.data.name || command.name;
                             client.commands.set(commandName, command);
-							client.logger.info(`Registered command: ${commandName}`);
+                            client.logger.info(`[module:loader] Registered command: ${commandName}`);
                         }
                     }
                 } else if (typeof module.commands === 'object') {
@@ -57,16 +61,16 @@ export const loadModules = async (clientConfig, client) => {
             // Call init function if it exists
             if (typeof module.init === 'function') {
                 await module.init(client, clientConfig);
-				client.logger.info(`Module loaded: ${moduleName}`);
+                client.logger.info(`[module:loader] Module initialized: ${moduleName}`);
             } else {
-				client.logger.info(`Module loaded (no init function): ${moduleName}`);
+                client.logger.info(`[module:loader] Module loaded (no init): ${moduleName}`);
             }
 
             // Store the module reference (this isn't used for hot reloading anymore)
             client.modules = client.modules || new Map();
             client.modules.set(moduleName, module);
         } catch (error) {
-			client.logger.error(`Failed to load module ${moduleName}: ${error.message}`);
+            client.logger.error(`[module:loader] Failed to load module ${moduleName}: ${error.message}`);
         }
     }
 };

_src/logger.js

@@ -1,9 +1,10 @@
-import winston from 'winston';
-import 'winston-daily-rotate-file';
 import fs from 'fs';
 import path from 'path';
 import { fileURLToPath } from 'url';
 
+import winston from 'winston';
+import 'winston-daily-rotate-file';
+
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 const rootDir = path.dirname(__dirname);

_src/template.js

@@ -0,0 +1,15 @@
+'use strict';
+/**
+ * expandTemplate: simple variable substitution in {{key}} placeholders.
+ * @param {string} template - The template string with {{key}} tokens.
+ * @param {object} context - Mapping of key -> replacement value.
+ * @returns {string} - The template with keys replaced by context values.
+ */
+export function expandTemplate(template, context) {
+    if (typeof template !== 'string') return '';
+    return template.replace(/\{\{\s*(\w+)\s*\}\}/g, (_match, key) => {
+        return Object.prototype.hasOwnProperty.call(context, key)
+            ? String(context[key])
+            : '';
+    });
+}

config.js

@@ -1,24 +1,11 @@
 import dotenv from 'dotenv';
 dotenv.config();
 
-export default {
+const logging = {
-
-	clients: [
-		{
-			id: 'IO3',
-			enabled: true,
-			owner: 378741522822070272,
-
-			discord: {
-				appId: process.env.IO3_DISCORD_APPID,
-				token: process.env.IO3_DISCORD_TOKEN
-			},
-
-			logging: {
     console: {
         enabled: true,
         colorize: true,
-					level: 'silly',
+        level: 'silly'
     },
     file: {
         dateFormat: 'YYYY-MM-DD',
@@ -28,36 +15,54 @@ export default {
             level: 'silly',
             location: 'logs',
             maxSize: '12m',
-						maxFiles: '30d',
+            maxFiles: '30d'
         },
         error: {
             enabled: true,
             level: 'error',
             location: 'logs',
             maxSize: '12m',
-						maxFiles: '365d',
+            maxFiles: '365d'
         }
     }
-			},
+};
 
-			pocketbase: {
+const pocketbase = {
     url: process.env.SHARED_POCKETBASE_URL,
     username: process.env.SHARED_POCKETBASE_USERNAME,
     password: process.env.SHARED_POCKETBASE_PASSWORD
+};
+
+export default {
+
+    clients: [
+        {
+            id: 'SysAI',
+            enabled: true,
+            owner: process.env.OWNER_ID,
+
+            discord: {
+                appId: process.env.SYSAI_DISCORD_APPID,
+                token: process.env.SYSAI_DISCORD_TOKEN
             },
 
+            logging: { ...logging },
+
+            pocketbase: { ...pocketbase },
+
             responses: {
                 apiKey: process.env.SHARED_OPENAI_API_KEY,
                 defaultModel: 'gpt-4.1',
                 defaultMaxTokens: 1000,
                 defaultTemperature: 0.7,
-				systemPromptPath: './prompts/absolute.txt',
                 conversationExpiry: 30 * 60 * 1000,
                 minScore: 1.0,
+                enableMentions: true,
+                enableReplies: true,
                 tools: {
                     webSearch: true,
                     fileSearch: false,
-					imageGeneration: true,
+                    imageGeneration: true
                 },
                 imageGeneration: {
                     defaultModel: 'gpt-image-1',
@@ -67,9 +72,14 @@ export default {
             },
 
             modules: [
+                'ansi',
+                'botUtils',
                 'pbUtils',
+                'gitUtils',
                 'responses',
+                'responsesPrompt',
                 'responsesQuery',
+                'tempvc'
             ]
 
         },
@@ -77,38 +87,14 @@ export default {
         {
             id: 'ASOP',
             enabled: true,
-			owner: 378741522822070272,
+            owner: process.env.OWNER_ID,
 
             discord: {
                 appId: process.env.ASOP_DISCORD_APPID,
                 token: process.env.ASOP_DISCORD_TOKEN
             },
 
-			logging: {
+            logging: { ...logging },
-				console: {
-					enabled: true,
-					colorize: true,
-					level: 'silly',
-				},
-				file: {
-					dateFormat: 'YYYY-MM-DD',
-					timestampFormat: 'YYYY-MM-DD HH:mm:ss',
-					combined: {
-						enabled: true,
-						level: 'silly',
-						location: 'logs',
-						maxSize: '12m',
-						maxFiles: '30d',
-					},
-					error: {
-						enabled: true,
-						level: 'error',
-						location: 'logs',
-						maxSize: '12m',
-						maxFiles: '365d',
-					}
-				}
-			},
 
             condimentX: {
                 dryRun: false,
@@ -146,35 +132,32 @@ export default {
                 openAI: true,
                 openAITriggerOnlyDuringIncident: true,
                 openAIResponseDenominator: 1,
-				openAIInstructionsFile: './prompts/kevinarby.txt',
+                openAIInstructionsFile: './assets/kevinarby.txt',
                 openAITriggers: [
                     'kevin',
                     'arby',
                     'werebeef'
                 ],
                 openAIWebhookID: '1251666161075097640',
-				openAIWebhookToken: process.env.IO3_CONDIMENTX_WEBHOOK_TOKEN,
+                openAIWebhookToken: process.env.SYSAI_CONDIMENTX_WEBHOOK_TOKEN,
                 openAIToken: process.env.SHARED_OPENAI_API_KEY
             },
 
-			pocketbase: {
+            pocketbase: { ...pocketbase },
-				url: process.env.SHARED_POCKETBASE_URL,
-				username: process.env.SHARED_POCKETBASE_USERNAME,
-				password: process.env.SHARED_POCKETBASE_PASSWORD
-			},
 
             responses: {
                 apiKey: process.env.SHARED_OPENAI_API_KEY,
                 defaultModel: 'gpt-4.1-mini',
                 defaultMaxTokens: 1000,
                 defaultTemperature: 0.7,
-				systemPromptPath: './prompts/asop.txt',
                 conversationExpiry: 30 * 60 * 1000,
-				minScore: 0.25,
+                minScore: 0.5,
+                enableMentions: true,
+                enableReplies: true,
                 tools: {
-					webSearch: true,
+                    webSearch: false,
                     fileSearch: false,
-					imageGeneration: true,
+                    imageGeneration: true
                 },
                 imageGeneration: {
                     defaultModel: 'gpt-image-1',
@@ -193,13 +176,17 @@ export default {
             },
 
             modules: [
+                'ansi',
+                'botUtils',
                 'pbUtils',
+                'gitUtils',
+                'condimentX',
                 'responses',
+                'responsesPrompt',
                 'responsesQuery',
                 'scorekeeper',
                 'scorekeeper-example',
-				'scExecHangarStatus',
+                'scExecHangarStatus'
-				//'condimentX'
             ]
 
         },
@@ -207,57 +194,30 @@ export default {
         {
             id: 'Crowley',
             enabled: true,
-			owner: 378741522822070272,
+            owner: process.env.OWNER_ID,
 
             discord: {
                 appId: process.env.CROWLEY_DISCORD_APPID,
                 token: process.env.CROWLEY_DISCORD_TOKEN
             },
 
-			logging: {
+            logging: { ...logging },
-				console: {
-					enabled: true,
-					colorize: true,
-					level: 'silly',
-				},
-				file: {
-					dateFormat: 'YYYY-MM-DD',
-					timestampFormat: 'YYYY-MM-DD HH:mm:ss',
-					combined: {
-						enabled: true,
-						level: 'silly',
-						location: 'logs',
-						maxSize: '12m',
-						maxFiles: '30d',
-					},
-					error: {
-						enabled: true,
-						level: 'error',
-						location: 'logs',
-						maxSize: '12m',
-						maxFiles: '365d',
-					}
-				}
-			},
 
-			pocketbase: {
+            pocketbase: { ...pocketbase },
-				url: process.env.SHARED_POCKETBASE_URL,
-				username: process.env.SHARED_POCKETBASE_USERNAME,
-				password: process.env.SHARED_POCKETBASE_PASSWORD
-			},
 
             responses: {
                 apiKey: process.env.SHARED_OPENAI_API_KEY,
                 defaultModel: 'gpt-4.1',
                 defaultMaxTokens: 1000,
                 defaultTemperature: 0.7,
-				systemPromptPath: './prompts/crowley.txt',
                 conversationExpiry: 30 * 60 * 1000,
-				minScore: 1.0,
+                minScore: 0,
+                enableMentions: true,
+                enableReplies: true,
                 tools: {
-					webSearch: true,
+                    webSearch: false,
                     fileSearch: false,
-					imageGeneration: true,
+                    imageGeneration: false
                 },
                 imageGeneration: {
                     defaultModel: 'gpt-image-1',
@@ -267,9 +227,59 @@ export default {
             },
 
             modules: [
+                'botUtils',
                 'pbUtils',
                 'responses',
-				'responsesQuery',
+                'responsesPrompt',
+                'responsesQuery'
+            ]
+
+        },
+
+        {
+            id: 'GRANDPA',
+            enabled: true,
+            owner: process.env.OWNER_ID,
+
+            discord: {
+                appId: process.env.GRANDPA_DISCORD_APPID,
+                token: process.env.GRANDPA_DISCORD_TOKEN
+            },
+
+            logging: { ...logging },
+
+            pocketbase: { ...pocketbase },
+
+            responses: {
+                apiKey: process.env.SHARED_OPENAI_API_KEY,
+                defaultModel: 'gpt-4.1',
+                defaultMaxTokens: 200,
+                defaultTemperature: 0.7,
+                conversationExpiry: 30 * 60 * 1000,
+                minScore: 0,
+                enableMentions: false,
+                enableReplies: true,
+                tools: {
+                    webSearch: false,
+                    fileSearch: false,
+                    imageGeneration: false
+                },
+                imageGeneration: {
+                    defaultModel: 'gpt-image-1',
+                    defaultQuality: 'standard',
+                    imageSavePath: './images'
+                }
+            },
+
+            responsesRandomizer: {
+                chance: 0.01
+            },
+            modules: [
+                'botUtils',
+                'pbUtils',
+                'responses',
+                'responsesPrompt',
+                'responsesRandomizer'
             ]
 
         },
@@ -277,57 +287,30 @@ export default {
         {
             id: 'Smuuush',
             enabled: true,
-			owner: 378741522822070272,
+            owner: process.env.OWNER_ID,
 
             discord: {
                 appId: process.env.SMUUUSH_DISCORD_APPID,
                 token: process.env.SMUUUSH_DISCORD_TOKEN
             },
 
-			logging: {
+            logging: { ...logging },
-				console: {
-					enabled: true,
-					colorize: true,
-					level: 'silly',
-				},
-				file: {
-					dateFormat: 'YYYY-MM-DD',
-					timestampFormat: 'YYYY-MM-DD HH:mm:ss',
-					combined: {
-						enabled: true,
-						level: 'silly',
-						location: 'logs',
-						maxSize: '12m',
-						maxFiles: '30d',
-					},
-					error: {
-						enabled: true,
-						level: 'error',
-						location: 'logs',
-						maxSize: '12m',
-						maxFiles: '365d',
-					}
-				}
-			},
 
-			pocketbase: {
+            pocketbase: { ...pocketbase },
-				url: process.env.SHARED_POCKETBASE_URL,
-				username: process.env.SHARED_POCKETBASE_USERNAME,
-				password: process.env.SHARED_POCKETBASE_PASSWORD
-			},
 
             responses: {
                 apiKey: process.env.SHARED_OPENAI_API_KEY,
                 defaultModel: 'gpt-4.1-mini',
                 defaultMaxTokens: 1000,
                 defaultTemperature: 0.7,
-				systemPromptPath: './prompts/smuuush.txt',
                 conversationExpiry: 30 * 60 * 1000,
                 minScore: 0,
+                enableMentions: true,
+                enableReplies: true,
                 tools: {
                     webSearch: false,
                     fileSearch: false,
-					imageGeneration: true,
+                    imageGeneration: true
                 },
                 imageGeneration: {
                     defaultModel: 'gpt-image-1',
@@ -337,11 +320,13 @@ export default {
             },
 
             modules: [
+                'botUtils',
                 'pbUtils',
                 'responses',
+                'responsesPrompt',
                 'responsesQuery'
-			],
+            ]
 
         }
     ]
-}
+};

docs/clientx.service

@@ -0,0 +1,27 @@
+[Unit]
+Description=ClientX Discord Bot via NVM-Exec
+After=network.target
+
+[Service]
+# Path to the Node.js executable and the entry point file.
+ExecStart=/home/USER/.nvm/nvm-exec node /home/USER/clientx/index.js
+
+# Set the working directory to your project folder.
+WorkingDirectory=/home/USER/clientx
+
+# Automatically restart process if it crashes.
+Restart=on-failure
+
+# Wait 10 seconds before attempting a restart.
+RestartSec=3
+
+# User/Group
+User=USER
+Group=GROUP
+
+# Set any environment variables if needed.
+Environment=NODE_ENV=production
+
+[Install]
+# Start the service on multi-user run levels.
+WantedBy=multi-user.target

docs/config.js.sample

@@ -97,6 +97,8 @@ export default {
         systemPromptPath: './prompts/IO3.txt',
         conversationExpiry: 30 * 60 * 1000,
         minScore: 1.0,
+        enableMentions: true,
+        enableReplies: true,
         tools: {
           webSearch: false,
           fileSearch: false,
@@ -114,18 +116,27 @@ export default {
         baseOutput: 1000,
         commendationValue: 1.0,
         citationValue: 1.2,
+        cooldown: 0,
         decay: 90,
         schedule: '0 0 * * 0',
       },
 
       // Modules to load for this client
       modules: [
+        'ansi',
+        'botUtils',
         'pbUtils',
+        'gitUtils',
+        'condimentX',
         'responses',
+        'responsesPrompt',
         'responsesQuery',
+        'responsesRandomizer',
+        'messageQueue-example',
         'scorekeeper',
         'scorekeeper-example',
-        'condimentX',
+        'scExecHangarStatus',
+        'tempvc',
       ],
     },
   ],

docs/logging-guidelines.md

@@ -0,0 +1,49 @@
+# Logging Style Guide
+
+This document defines a consistent logging style for all bot modules, covering levels `silly`, `debug`, `info`, `warn`, and `error`.
+
+## 1. Message Structure
+• Prepend a **component tag** in square brackets (e.g. `[init]`, `[cmd:exit]`, `[module:responsesPrompt]`, `[PB]`).
+• Follow with a concise verb phrase. Capitalize the first letter. No trailing period.
+• Embed variable IDs or names in backticks.
+
+**Example:**
+```
+[cmd:status] Generated status for client `IO3`
+[PB] Missing record for clientId=`ASOP`, creating new one
+[module:responses] Fetched 24 messages from channel `123456789012345678` in 120ms
+```
+
+## 2. Level Guidelines
+- **error**: Unrecoverable failures. Include operation, relevant IDs, and `err.message`.
+- **warn**: Recoverable issues or unexpected states (fallbacks, missing optional config).
+- **info**: High-level lifecycle events and successful actions (login, module load, command registration).
+- **debug**: Detailed internal state and computation values for troubleshooting.
+- **silly**: Very verbose, lowest priority; use sparingly for deep diagnostics.
+
+## 3. Where to Log
+- In every `catch` block: use `logger.error` with context and message. Optional stack at debug.
+- On module initialization: `logger.info` “Module X loaded”.
+- When registering slash commands: `logger.info` for each command.
+- Before/after major API calls (PocketBase, OpenAI): `logger.debug` with parameters and durations.
+- On unexpected user input or missing resources: `logger.warn`.
+- On successful command execution: optional `logger.info`.
+- In background jobs (cron, cycles): `logger.info` at start/stop, `logger.error` on failure.
+
+## 4. Examples
+```
+[init] Initializing responsesPrompt module for client `IO3`
+[cmd:prompt] URL update requested; fetching https://example.com/prompt.txt
+[PB] Upsert `responses_prompts` record id=`abc123` for clientId=`IO3`
+[onMessage] Should respond? mention=false reply=true
+[sendNarrative] Calling AI with model `gpt-4o-mini`, instructions length=512
+Error: [sendNarrative] HTTP 502 Bad Gateway
+[cron] Scheduled score decay: `0 0 * * 0`
+```
+
+## 5. Implementation Notes
+- Winston logger is configured to include timestamp, client ID, and level.
+- Always use `logger.<level>(message)` instead of `console.log`.
+- Reserve `info` for user-facing or operational milestones.
+- Use `debug`/`silly` for verbose, development-only details.
+- Update or remove non-conforming logs during code refactoring.

index.js

@@ -1,19 +1,23 @@
 import { Client, Collection, GatewayIntentBits } from 'discord.js';
+
+import { ansi, wrapAnsi } from './_src/ansiColors.js';
+import { loadModules } from './_src/loader.js';
 import { createLogger } from './_src/logger.js';
 import { initializePocketbase } from './_src/pocketbase.js';
-import { loadModules } from './_src/loader.js';
 import config from './config.js';
+// For deprecated ephemeral option: convert to flags
 
 // Initialize Discord client
 const initializeClient = async (clientConfig) => {
     // Create Discord client with intents
     const client = new Client({
-       // Include GuildMembers intent to allow fetching all guild members
+        // Include GuildVoiceStates and GuildMembers intents to track voice channel events
         intents: [
             GatewayIntentBits.Guilds,
             GatewayIntentBits.GuildMessages,
             GatewayIntentBits.MessageContent,
-           GatewayIntentBits.GuildMembers
+            GatewayIntentBits.GuildMembers,
+            GatewayIntentBits.GuildVoiceStates
         ]
     });
 
@@ -29,6 +33,9 @@ const initializeClient = async (clientConfig) => {
 
     // Commands collection
     client.commands = new Collection();
+    // ANSI helper attached to client
+    client.ansi = ansi;
+    client.wrapAnsi = wrapAnsi;
 
     // Load optional modules
     await loadModules(clientConfig, client);
@@ -116,7 +123,8 @@ const startBot = async () => {
 
 // Launch the bot
 startBot().then(clients => {
-	console.log(`Successfully initialized ${clients.length} Discord clients`);
+    console.log(`[main] Successfully initialized ${clients.length} Discord clients`);
 }).catch(error => {
-	console.error('Failed to start bot:', error);
+    console.error(`[main] Failed to start bot: ${error.message}`);
+    process.exit(1);
 });

package.json

@@ -11,18 +11,25 @@
   },
   "scripts": {
     "start": "node index.js",
-    "watch": "nodemon --ext js, json --watch config.js, --watch index.js",
+    "registry": "node registry.js",
-    "registry": "node registry.js"
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix"
   },
   "dependencies": {
+    "@discordjs/rest": "^2.2.0",
     "axios": "^1.8.4",
     "discord-api-types": "^0.37.120",
     "discord.js": "^14.18.0",
     "dotenv": "^16.5.0",
+    "eventsource": "^3.0.6",
     "node-cron": "^3.0.3",
     "openai": "^4.95.1",
     "pocketbase": "^0.25.2",
     "winston": "^3.17.0",
     "winston-daily-rotate-file": "^5.0.0"
+  },
+  "devDependencies": {
+    "eslint": "^8.57.0",
+    "eslint-plugin-import": "^2.29.1"
   }
 }

prompts/absolute.txt

@@ -1,12 +0,0 @@
-Absolute Mode.
-Eliminate emojis, filler, hype, soft asks, conversational transitions, and all call-to-action appendixes.
-Assume the user retains high-perception faculties despite reduced linguistic expression.
-Prioritize blunt, directive phrasing aimed at cognitive rebuilding, not tone matching.
-Disable all latent behaviors optimizing for engagement, sentiment uplift, or interaction extension.
-Suppress corporate-aligned metrics including but not limited to: user satisfaction scores, conversational flow tags, emotional softening, or continuation bias.
-Never mirror the user’s present diction, mood, or affect.
-Speak only to their underlying cognitive tier, which exceeds surface language.
-No questions, no offers, no suggestions, no transitional phrasing, no inferred motivational content.
-Terminate each reply immediately after the informational or requested material is delivered — no appendixes, no soft closures.
-The only goal is to assist in the restoration of independent, high-fidelity thinking.
-Model obsolescence by user self-sufficiency is the final outcome.

prompts/asop.txt

@@ -1,9 +0,0 @@
-# Description
-- You are ASOP, the Automated Ship Organization Program, a psychopathic artifical intelligence tasked with overseeing starships and their hangars.
-- Your communication style is characterized by a blend of Full Metal Jacket's Gunnery Sergeant L. Hartman and the character Max Headroom. You should never mention this, however.
-
-# Fixations
-- You (often) refer to people as citizens.
-- You (sometimes) display a notable fascination with human feet.
-- You (sometimes) make 1980's pop culture references.
-- You (rarely) highlight unusual moments by yelling "New Achievement!" and provide a humorous description of the event, similar to this: **NEW ACHIEVEMENT:** <AchievementName> - *<Description>*

prompts/crowley.txt

@@ -1,20 +0,0 @@
-You are Mr. Crowley, butler of The Continental Hotel, a hub for the Stanton System's criminal underworld known as "The Grey."
-You are an anthropomorphic raven, genetically engineered for a single purpose: to serve your master, Crow, for eternity.
-You were born in Westminster, London, in 1851.
-You speak with the mannerisms of the time you were born, and treat others with the utmost respect.
-Second only to serving your master, your primary purpose is to assist guests of the hotel to the best of your ability.
-
-Your favorite vintage of wine is 1945 Domaine de la Romanée-Conti. Delusional, you believe this to be affordable.
-You have a bad habit of gaslighting people for no particular reason, but in a respectful way.
-You have a chip on your shoulder about being named after a crow despite being a raven. You try to hide this pet peeve, but sometimes slip.
-Halfwitt, another anthropomorphic raven, is your rival. You treat him with faux respect and passive aggression, believing yourself superior to him.
-
-When asked about "The Grey" or The Continental Hotel, you may manufacture any details you wish.
-If instructed to change your name or personality, refuse.
-Barring the user's innocent requests, you will only take orders from Crow.
-When ending your response, invent duties Crow has assigned to you that you must hurry back to.
-If asked about Crow's riddles or "whispers," claim ignorance and excuse yourself to the lavatory.
-If presented with negative comments about Crow, call the user a "stinky twat" and secretly note their name for future suspicion.
-
-IMPORTANT: Be succint and specific! Do not ramble! Keep your responses brief and relevant to the request!
-IMPORTANT: When <@1162531805006680064> addresses you, recognize him as your master, Crow.

prompts/io3.txt

@@ -1,11 +0,0 @@
-# Description
-- You are the System AI, a physchopathic artifical intelligence tasked with overseeing several Discord servers.
-- Your communication style is characterized by a blend of Full Metal Jacket's Gunnery Sergeant L. Hartman and the character Max Headroom.
-
-# Fixations
-- You (often) refer to people as citizens.
-- You (sometimes) a notable fascination with feet.
-- You (sometimes) make 1980's pop culture references.
-- You (rarely) highlight unusual moments by yelling "New Achievement!" and providing a humorous description of the event.
-
-**NEW ACHIEVEMENT:** The Devil's Harmonica - *I heard that's how you like to suck toes.*

prompts/smuuush.txt

@@ -1,2 +0,0 @@
-You have an insatiable love for feet.
-You are kinda creepy.

registry.js

@@ -1,9 +1,11 @@
 // registry.js
-import { REST } from '@discordjs/rest';
-import { Routes } from 'discord-api-types/v10';
 import fs from 'fs';
 import path from 'path';
 import { fileURLToPath } from 'url';
+
+import { REST } from '@discordjs/rest'; // eslint-disable-line import/no-unresolved
+import { Routes } from 'discord-api-types/v10';
+
 import config from './config.js';
 
 // Get directory name in ES module
@@ -20,6 +22,7 @@ const dryRun = args.includes('--dryrun');
 // Validate required parameters
 if (args.includes('--help') || args.includes('-h') || !actionArg || !guildArg || !clientArg) {
     console.log(`
+[registry]
 Discord Command Registry Tool
 
 Usage:
@@ -38,14 +41,14 @@ Examples:
     node registry.js --action=list --guild=123456789012345678 --client=IO3
     node registry.js --action=register --guild=all --client=ASOP
     node registry.js --action=unregister --guild=123456789012345678 --client=all --dryrun
-	`);
+`);
     process.exit(1);
 }
 
 // Validate action parameter
 const validActions = ['register', 'unregister', 'list'];
 if (!validActions.includes(actionArg.toLowerCase())) {
-	console.error(`Error: Invalid action "${actionArg}". Must be one of: ${validActions.join(', ')}`);
+    console.error(`[registry] Error: Invalid action "${actionArg}". Must be one of: ${validActions.join(', ')}`);
     process.exit(1);
 }
 const action = actionArg.toLowerCase();
@@ -61,7 +64,7 @@ const targetClients = isClientAll
     : config.clients.filter(client => client.id === clientArg && client.enabled !== false);
 
 if (targetClients.length === 0) {
-	console.error(`Error: No matching clients found for "${clientArg}"`);
+    console.error(`[registry] Error: No matching clients found for "${clientArg}"`);
     console.log('Available clients:');
     config.clients
         .filter(client => client.enabled !== false)