Feat | Context Notes (Author notes)

Author: Bredrumb

docs/ai/context-assembly.md

@@ -129,6 +129,35 @@ If the preset is deactivated or deleted, context assembly immediately reverts to
 
 See [ST Preset System — Context Assembly Override](../integrations/sillytavern-preset-system.md#context-assembly-override-phase-3) for the full algorithm with a worked before/after example.
 
+## Author's Note (Context Note) Injection
+
+TomoriBot supports a user-configurable **author's note** injected into the conversation history block at a specified depth. This is the TomoriBot equivalent of the author's note feature in NovelAI/SillyTavern — a short reminder string placed near the model's most recent attention to reduce context drift.
+
+### Storage and Fallback
+
+Two storage scopes exist, set via `/config context-note set`:
+
+| Scope | Table | Column |
+|---|---|---|
+| Per-persona | `tomoris` | `context_note`, `context_note_depth` |
+| Global (server-wide) | `tomori_configs` | `context_note`, `context_note_depth` |
+
+At inference, the **active persona's note takes priority** over the global note. If the active persona has no note (column is `NULL`), the global note is used as a fallback. If neither is set, no injection occurs.
+
+### Depth Semantics
+
+`depth` is an integer from `0` to `100` (Discord's message-fetch max):
+
+- `depth=0` → injected **after** all fetched history messages (the most recent position)
+- `depth=N` → injected before the message at position `totalMessages - N` from the start
+- `depth >= totalMessages` → clamped to the **top** of the conversation history
+
+### Injection Format
+
+The note is emitted as a `"user"` role context item with `[System: Author's note — <text>]` formatting, matching the existing convention for system annotations in the dialogue stream (short-term memory summaries, users-in-conversation headers, etc.). No new `authorType` was added.
+
+**Implementation location:** `buildContextNative()` in `src/utils/text/contextBuilder.ts` — the pre-loop setup computes `contextNoteTargetIndex`, and the in-loop guard emits the note at that index. A post-loop fallback handles `depth=0`.
+
 ## Key Behaviors
 
 ### User Impersonation Bypass

docs/systems/command-system.md

@@ -268,7 +268,7 @@ Rules:
 ## Representative Command Groups
 
 - `bot`: respond, generate(image), kill, impersonate
-- `config`: setup, model(text/image/embedding), api-key(set/delete/rotation), system-prompt(set/remove/preset), params(*), timezone, message-fetch-limit, bot-permissions
+- `config`: setup, model(text/image/embedding), api-key(set/delete/rotation), system-prompt(set/remove/preset), context-note(set), params(*), timezone, message-fetch-limit, bot-permissions
 - `nsfw`: jailbreaks
 - `optional-key`: google/set/remove, brave/set/remove, elevenlabs/set/remove, novelai/set/remove
 - `server`: trigger(add/delete), whitelist(channel/role/remove), stm(manage), cooldown(triggers), auto-trigger(channels/threshold), matrix(link/unlink), quota(image-generation/text-generation/video-generation/reset), rp-channels, crosschannel-blocklist, welcome-channel(set/remove), private-channels, user-blacklist(add/remove), member-permissions, always-reply, thought-logs-channel

docs/systems/database-schema.md

@@ -105,6 +105,10 @@ Also requires pgvector (`CREATE EXTENSION IF NOT EXISTS vector`).
 - `tomori_configs.llm_logit_biases` stores server-wide logit-bias entries as raw text/token-ID input plus tokenizer-specific cached resolutions. Raw text stays canonical so entries can be refreshed when `llm_id` changes.
 - `tomori_configs.videogen_enabled` gates both slash-command and tool-driven video generation exposure.
 - `tomori_configs.video_model_id` stores the active server-scoped video generation model selection.
+- `tomori_configs.context_note` stores the server-wide author's note injected into conversation history at inference time. Acts as a fallback when the active persona has no persona-specific note.
+- `tomori_configs.context_note_depth` stores the injection depth for the global note: `0` = bottom of fetched history (most recent), `N` = N messages from the bottom, clamped to top if it exceeds the actual count.
+- `tomoris.context_note` stores a per-persona author's note. Takes priority over `tomori_configs.context_note` at inference when non-null.
+- `tomoris.context_note_depth` stores the injection depth for the persona-specific note, using the same semantics as `tomori_configs.context_note_depth`.
 
 ### NovelAI profile tags
 

src/commands/config/context-note/set.ts

@@ -0,0 +1,276 @@
+/**
+ * Command: /config context-note set
+ * Allows users to set an author's note injected into conversation history
+ * at a configurable depth to combat context drift.
+ *
+ * Scopes:
+ * - persona: Bound to a specific persona (persona picker shown first)
+ * - global:  Server-wide fallback used when the active persona has no note
+ *
+ * At inference, the active persona's note takes priority over the global note.
+ * Submitting a blank note clears (removes) the stored value.
+ */
+
+import type { ButtonInteraction, ChatInputCommandInteraction, Client, ModalSubmitInteraction } from "discord.js";
+import { MessageFlags, TextInputStyle } from "discord.js";
+import type { TomoriState, UserRow } from "@/types/db/schema";
+import { sql } from "@/utils/db/client";
+import { getCachedTomoriState, invalidateTomoriStateCache } from "@/utils/cache/tomoriStateCache";
+import { loadAllPersonasForServer } from "@/utils/db/dbRead";
+import { localizer } from "@/utils/text/localizer";
+import { log, ColorCode } from "@/utils/misc/logger";
+import { replyInfoEmbed, promptWithRawModal, replyPaginatedPersonaChoicesV2 } from "@/utils/discord/interactionHelper";
+
+const MODAL_CUSTOM_ID = "config_context_note_modal";
+const CONTEXT_NOTE_MAX_LENGTH = 2000;
+const CONTEXT_NOTE_DEPTH_MAX = 100;
+
+/**
+ * Configure the /config context-note set subcommand metadata.
+ * The commandLoader auto-localizes descriptions, option descriptions, and choice labels
+ * from the keys at commands.config.context-note.set.* in the locale files.
+ * @param subcommand - Builder provided by commandLoader
+ * @returns Configured builder
+ */
+export const configureSubcommand = (subcommand: import("discord.js").SlashCommandSubcommandBuilder) =>
+  subcommand
+    .setName("set")
+    .setDescription(localizer("en-US", "commands.config.context-note.set.description"))
+    .addStringOption((option) =>
+      option
+        .setName("scope")
+        .setDescription(localizer("en-US", "commands.config.context-note.set.scope_description"))
+        .setRequired(true)
+        .addChoices(
+          {
+            name: localizer("en-US", "commands.config.context-note.set.persona_option"),
+            value: "persona",
+          },
+          {
+            name: localizer("en-US", "commands.config.context-note.set.global_option"),
+            value: "global",
+          },
+        ),
+    );
+
+/**
+ * Execute /config context-note set.
+ * @param _client - Discord client (unused)
+ * @param interaction - Chat input command interaction
+ * @param _userData - User row (unused)
+ * @param locale - User's locale for localization
+ */
+export async function execute(
+  _client: Client,
+  interaction: ChatInputCommandInteraction,
+  _userData: UserRow,
+  locale: string,
+): Promise<void> {
+  // 1. Channel guard
+  if (!interaction.channel) {
+    await replyInfoEmbed(interaction, locale, {
+      titleKey: "general.errors.channel_only_title",
+      descriptionKey: "general.errors.channel_only_description",
+      color: ColorCode.ERROR,
+      flags: MessageFlags.Ephemeral,
+    });
+    return;
+  }
+
+  // 2. Resolve server identity and fetch cached state
+  const serverId = interaction.guildId ?? interaction.user.id;
+  const tomoriState = await getCachedTomoriState(serverId);
+
+  if (!tomoriState) {
+    await replyInfoEmbed(interaction, locale, {
+      titleKey: "general.errors.tomori_not_setup_title",
+      descriptionKey: "general.errors.tomori_not_setup_description",
+      color: ColorCode.ERROR,
+      flags: MessageFlags.Ephemeral,
+    });
+    return;
+  }
+
+  // 3. Read required scope option
+  const scope = interaction.options.getString("scope", true) as "persona" | "global";
+
+  // 4. Declare interaction handles outside try-catch for fallback error replies
+  let modalHost: ChatInputCommandInteraction | ButtonInteraction = interaction;
+  let modalSubmitInteraction: ModalSubmitInteraction | undefined;
+  let selectedPersona: TomoriState | null = null;
+
+  try {
+    // 5. Persona scope: show paginated persona picker first
+    if (scope === "persona") {
+      const allPersonas = await loadAllPersonasForServer(interaction.guild?.id ?? interaction.user.id);
+
+      if (allPersonas.length === 0) {
+        await replyInfoEmbed(interaction, locale, {
+          titleKey: "commands.config.context-note.set.no_personas_title",
+          descriptionKey: "commands.config.context-note.set.no_personas_description",
+          color: ColorCode.ERROR,
+          flags: MessageFlags.Ephemeral,
+        });
+        return;
+      }
+
+      // 5a. Display paginated persona picker; preserveSelectedInteraction=true
+      //     returns the unacknowledged ButtonInteraction so we can show a modal on it.
+      const personaSelection = await replyPaginatedPersonaChoicesV2(interaction, locale, {
+        personas: allPersonas,
+        color: ColorCode.INFO,
+        preserveSelectedInteraction: true,
+        onSelect: async () => {},
+      });
+
+      if (!personaSelection.success || !personaSelection.interaction || personaSelection.selectedIndex === undefined) {
+        return;
+      }
+
+      // 5b. Hand the ButtonInteraction to promptWithRawModal instead of ChatInputCommandInteraction
+      modalHost = personaSelection.interaction;
+      selectedPersona = allPersonas[personaSelection.selectedIndex] ?? null;
+
+      if (!selectedPersona?.tomori_id) {
+        return;
+      }
+    }
+
+    // 6. Load existing values for pre-fill
+    let existingNote: string | null | undefined;
+    let existingDepth: number;
+
+    if (scope === "persona" && selectedPersona) {
+      existingNote = selectedPersona.context_note;
+      existingDepth = selectedPersona.context_note_depth ?? 0;
+    } else {
+      existingNote = tomoriState.config.context_note;
+      existingDepth = tomoriState.config.context_note_depth ?? 0;
+    }
+
+    // 7. Show modal with note text + depth fields, pre-filled with existing values
+    const modalResult = await promptWithRawModal(
+      modalHost,
+      locale,
+      {
+        modalCustomId: MODAL_CUSTOM_ID,
+        modalTitleKey: "commands.config.context-note.set.modal_title",
+        components: [
+          {
+            customId: "context_note_text",
+            style: TextInputStyle.Paragraph,
+            labelKey: "commands.config.context-note.set.text_label",
+            placeholder: "commands.config.context-note.set.text_placeholder",
+            required: false,
+            maxLength: CONTEXT_NOTE_MAX_LENGTH,
+            value: existingNote || undefined,
+          },
+          {
+            customId: "context_note_depth",
+            style: TextInputStyle.Short,
+            labelKey: "commands.config.context-note.set.depth_label",
+            placeholder: "commands.config.context-note.set.depth_placeholder",
+            required: true,
+            maxLength: 3,
+            value: String(existingDepth),
+          },
+        ],
+      },
+      MessageFlags.Ephemeral,
+    );
+
+    if (modalResult.outcome !== "submit") {
+      log.info(`Context note modal ${modalResult.outcome}`);
+      return;
+    }
+
+    // 8. Assign (not declare) after successful submit
+    modalSubmitInteraction = modalResult.interaction;
+
+    if (!modalSubmitInteraction) {
+      log.error("Modal submit interaction is undefined after successful submit");
+      return;
+    }
+
+    // 9. Parse and validate the submitted values
+    const rawNote = (modalResult.values?.context_note_text ?? "").trim();
+    const rawDepth = (modalResult.values?.context_note_depth ?? "0").trim();
+    const parsedDepth = Number.parseInt(rawDepth, 10);
+
+    if (Number.isNaN(parsedDepth) || parsedDepth < 0 || parsedDepth > CONTEXT_NOTE_DEPTH_MAX) {
+      await replyInfoEmbed(modalSubmitInteraction, locale, {
+        titleKey: "commands.config.context-note.set.invalid_depth_title",
+        descriptionKey: "commands.config.context-note.set.invalid_depth_description",
+        color: ColorCode.ERROR,
+        flags: MessageFlags.Ephemeral,
+      });
+      return;
+    }
+
+    // 10. Blank text = remove the note (NULL + reset depth to 0)
+    const noteToStore = rawNote || null;
+    const depthToStore = rawNote ? parsedDepth : 0;
+    const isRemoving = !rawNote;
+
+    // 11. Persist to the appropriate table
+    if (scope === "persona" && selectedPersona?.tomori_id) {
+      await sql`
+        UPDATE tomoris
+        SET context_note = ${noteToStore},
+            context_note_depth = ${depthToStore}
+        WHERE tomori_id = ${selectedPersona.tomori_id}
+      `;
+    } else {
+      await sql`
+        UPDATE tomori_configs
+        SET context_note = ${noteToStore},
+            context_note_depth = ${depthToStore}
+        WHERE server_id = ${tomoriState.server_id}
+      `;
+    }
+
+    // 12. Invalidate cache AFTER the successful write
+    invalidateTomoriStateCache(serverId);
+
+    // 13. Reply with scoped success message
+    const scopeLabel =
+      scope === "persona" && selectedPersona
+        ? selectedPersona.tomori_nickname
+        : localizer(locale, "commands.config.context-note.set.global_option");
+
+    if (isRemoving) {
+      await replyInfoEmbed(modalSubmitInteraction, locale, {
+        titleKey: "commands.config.context-note.set.success_removed_title",
+        descriptionKey: "commands.config.context-note.set.success_removed_description",
+        descriptionVars: { scope: scopeLabel },
+        color: ColorCode.SUCCESS,
+        flags: MessageFlags.Ephemeral,
+      });
+    } else {
+      const preview = (noteToStore ?? "").substring(0, 200);
+      await replyInfoEmbed(modalSubmitInteraction, locale, {
+        titleKey: "commands.config.context-note.set.success_set_title",
+        descriptionKey: "commands.config.context-note.set.success_set_description",
+        descriptionVars: { scope: scopeLabel, depth: String(depthToStore), preview },
+        color: ColorCode.SUCCESS,
+        flags: MessageFlags.Ephemeral,
+      });
+    }
+
+    log.info(
+      `Context note ${isRemoving ? "cleared" : "updated"} for server ${serverId} scope=${scope}${selectedPersona ? ` persona=${selectedPersona.tomori_id}` : ""} depth=${depthToStore}`,
+    );
+  } catch (error) {
+    log.error("Failed to set context note:", error as Error);
+
+    // 14. Use the most specific available interaction for the error reply
+    const replyTarget = modalSubmitInteraction ?? modalHost;
+
+    await replyInfoEmbed(replyTarget, locale, {
+      titleKey: "general.errors.unknown_error_title",
+      descriptionKey: "general.errors.unknown_error_description",
+      color: ColorCode.ERROR,
+      flags: MessageFlags.Ephemeral,
+    });
+  }
+}

src/db/schema.sql

@@ -2095,3 +2095,18 @@ DROP TRIGGER IF EXISTS update_saved_provider_configs_timestamp ON saved_provider
 CREATE TRIGGER update_saved_provider_configs_timestamp
   BEFORE UPDATE ON saved_provider_configs
   FOR EACH ROW EXECUTE FUNCTION update_timestamp();
+
+-- ============================================================
+-- Context Note / Author's Note (April 2026)
+-- Short reminder string injected into conversation history at a
+-- user-specified depth from the bottom to reduce context drift.
+-- Persona value wins at inference; server (global) value is the fallback.
+-- depth=0 means "at the very bottom" (after all fetched messages).
+-- depth=N means N messages above the bottom; clamped to top if N > total.
+-- ============================================================
+-- Per-persona note (on tomoris)
+SELECT add_column_if_not_exists('tomoris', 'context_note', 'TEXT', 'NULL');
+SELECT add_column_if_not_exists('tomoris', 'context_note_depth', 'INTEGER', '0');
+-- Server-wide / global fallback note (on tomori_configs)
+SELECT add_column_if_not_exists('tomori_configs', 'context_note', 'TEXT', 'NULL');
+SELECT add_column_if_not_exists('tomori_configs', 'context_note_depth', 'INTEGER', '0');