feat(storyteller): request queue identity unification, envelope hints, and CI test workflow

.github/workflows/test.yml

@@ -0,0 +1,22 @@
+name: Unit Tests
+
+on:
+  push:
+    branches: [main, master]
+    paths:
+      - 'Source/**'
+      - 'Tests/**'
+      - 'ArchTests/**'
+      - '.github/workflows/test.yml'
+  pull_request:
+    branches: [main, master]
+    paths:
+      - 'Source/**'
+      - 'Tests/**'
+      - 'ArchTests/**'
+      - '.github/workflows/test.yml'
+
+jobs:
+  test:
+    uses: RimWorld-RimMind-Mod/Workflows/.github/workflows/test.yml@main
+    secrets: inherit

Source/Extensions/StorytellerModCooldown.cs

@@ -7,8 +7,9 @@ internal sealed class StorytellerModCooldown : IModCooldown
     {
         private readonly RimMindStorytellerSettings _settings;
         public StorytellerModCooldown(RimMindStorytellerSettings settings) { _settings = settings; }
-        public string Id => "Storyteller";
-        public string OwnerModId => "RimMind.Storyteller";
+        // Must equal the envelope ModId: Core resolves and stores queue cooldowns by that key.
+        public string Id => StorytellerRequestIds.RequestModId;
+        public string OwnerModId => StorytellerRequestIds.RequestModId;
         public int CooldownTicks => (int)(_settings.mtbDays * 60000f);
     }
 }

Source/Patch/Patch_IncidentWorker_TryExecute.cs

@@ -7,7 +7,7 @@
 
 namespace RimMind.Storyteller.Patch
 {
-    [HarmonyPatch(typeof(IncidentWorker), "TryExecute")]
+    [HarmonyPatch(typeof(IncidentWorker), nameof(IncidentWorker.TryExecute))]
     public static class Patch_IncidentWorker_TryExecute
     {
         static void Postfix(IncidentWorker __instance, IncidentParms parms, bool __result)
@@ -27,9 +27,9 @@
             if (!isThreat || parms?.quest != null)
                 return;
 
             RimMindAPI.NotifyIncidentExecuted();
 
             if (RimMindAPI.CanTriggerDialogue)
             {
                 var map = parms?.target as Map;
                 if (map != null)
@@ -50,7 +50,7 @@
                         string incidentContext = "RimMind.Storyteller.Context.IncidentOccurred".CanTranslate()
                             ? "RimMind.Storyteller.Context.IncidentOccurred".Translate(__instance.def.label).ToString()
                             : $"Incident occurred: {__instance.def.label}";
                         RimMindAPI.TriggerDialogue(pawn, incidentContext);
                     }
                 }
             }

Source/Storyteller/StorytellerContextProviderRegistrar.cs

@@ -1,5 +1,9 @@
+using System;
+using System.Collections.Generic;
 using System.Text;
 using RimMind.Application.Common.Interfaces.Context;
+using RimMind.Application.Common.Models.Context;
+using RimMind.Application.Features.Context;
 using RimMind.Domain.ValueObjects;
 using RimMind.Presentation.Api;
 using RimMind.Storyteller.Extensions;
@@ -13,18 +17,58 @@ internal static class StorytellerContextProviderRegistrar
         private const string ModId = RimMind.Application.Common.Constants.RimMindOwnerConsts.StorytellerModId;
 
         private static string Tr(string key, params object[] args)
-        {
-            try
-            {
-                if (string.IsNullOrEmpty(key)) return string.Empty;
-                string template = key.CanTranslate() ? key.TranslateSimple() : key;
-                return (args == null || args.Length == 0) ? template : string.Format(template, args);
-            }
-            catch { return key ?? string.Empty; }
-        }
+            => RimMindText.TrOr(key, key ?? string.Empty, args);
 
         internal static void RegisterAll()
         {
+            // Register the typed event before any key names it, so the trigger resolves
+            // to a real event (unknown names never fall back to the base bus event).
+            StorytellerStateChangedEvent.Register();
+
+            ScenarioRegistry.Register(new ScenarioDescriptor
+            {
+                Id = ScenarioIds.Storyteller,
+                DefaultBaseRounds = 8,
+                Description = "RimMind.Application.Scenario.Storyteller",
+                DefaultBudget = 0.7f,
+                L4Mode = L4Mode.NarrativeMemory,
+                DefaultExcludeKeys = new[]
+                {
+                    "npc_identity", "pawn_base_info", "fixed_relations",
+                    "ideology", "skills_summary", "health", "mood", "current_job",
+                    "combat_status", "target_info", "task_progress", "npc_commands"
+                },
+                OwnerModId = ModId,
+                RelevanceWeights = new Dictionary<string, float>(StringComparer.Ordinal)
+                {
+                    ["health"] = 0.3f,
+                    ["mood"] = 0.4f,
+                    ["current_job"] = 0.2f,
+                    ["combat_status"] = 0.8f,
+                    ["target_info"] = 0.7f,
+                    ["task_progress"] = 0.3f,
+                    ["nearby_pawns"] = 0.5f,
+                    ["colony_status"] = 0.9f,
+                    ["current_area"] = 0.4f,
+                    ["weather"] = 0.6f,
+                    ["time_of_day"] = 0.5f,
+                    ["season"] = 0.7f,
+                    ["map_structure"] = 0.8f,
+                    ["pawn_base_info"] = 0.3f,
+                    ["fixed_relations"] = 0.3f,
+                    ["ideology"] = 0.4f,
+                    ["skills_summary"] = 0.2f,
+                    ["memory_pawn"] = 0.3f,
+                    ["working_memory"] = 0.2f,
+                    ["memory_narrator"] = 0.9f,
+                    ["storyteller_dialogue"] = 0.6f,
+                    ["storyteller_task"] = 0.95f,
+                    ["storyteller_context"] = 0.95f,
+                    ["storyteller_reactions"] = 0.9f,
+                    ["storyteller_recent_incidents"] = 0.85f
+                }
+            });
+
             RimMindAPI.Context.ContextKeys.Register(new ContextProviderDef(
                 "storyteller_dialogue", ContextLayer.L3_State, 0.5f,
                 async (ctx, ct) =>
@@ -42,7 +86,7 @@ internal static void RegisterAll()
                             ? null
                             : $"{Tr("RimMind.Storyteller.Dialogue.StorytellerDialogueHeader")}\n{dialogue}";
                     }, null, ct: ct).ConfigureAwait(false);
-                }, ownerMod: ModId, stalenessTicks: 750, invalidationTriggers: new[] { "StorytellerEvent" },
+                }, ownerMod: ModId, stalenessTicks: 750, invalidationTriggers: new[] { StorytellerStateChangedEvent.EventName },
                 cacheScope: CacheScope.Scenario));
 
             RimMindAPI.Context.ContextKeys.Register(new ContextProviderDef(
@@ -74,7 +118,7 @@ internal static void RegisterAll()
                             StorytellerMemory.Instance?.CustomSystemPrompt,
                             taskInstruction);
                     }, null, ct: ct).ConfigureAwait(false);
-                }, ownerMod: ModId, stalenessTicks: 0, invalidationTriggers: new[] { "StorytellerEvent" },
+                }, ownerMod: ModId, stalenessTicks: 0,
                 cacheScope: CacheScope.Static));
 
             RimMindAPI.Context.ContextKeys.Register(new ContextProviderDef(
@@ -104,7 +148,7 @@ internal static void RegisterAll()
                             sb.AppendLine(chains);
                         return sb.ToString().TrimEnd();
                     }, null, ct: ct).ConfigureAwait(false);
-                }, ownerMod: ModId, stalenessTicks: 3000, invalidationTriggers: new[] { "StorytellerEvent" },
+                }, ownerMod: ModId, stalenessTicks: 3000, invalidationTriggers: new[] { StorytellerStateChangedEvent.EventName },
                 cacheScope: CacheScope.Scenario));
 
             RimMindAPI.Context.ContextKeys.Register(new ContextProviderDef(
@@ -122,7 +166,7 @@ internal static void RegisterAll()
                         string? text = mem.ConsumedReactionsText;
                         return !string.IsNullOrEmpty(text) ? text : null;
                     }, null, ct: ct).ConfigureAwait(false);
-                }, ownerMod: ModId, stalenessTicks: 3000, invalidationTriggers: new[] { "StorytellerEvent" },
+                }, ownerMod: ModId, stalenessTicks: 3000, invalidationTriggers: new[] { StorytellerStateChangedEvent.EventName },
                 cacheScope: CacheScope.Scenario));
 
             RimMindAPI.Context.ContextKeys.Register(new ContextProviderDef(
@@ -147,7 +191,7 @@ internal static void RegisterAll()
                         }
                         return narrationText.ToString().TrimEnd();
                     }, null, ct: ct).ConfigureAwait(false);
-                }, ownerMod: ModId, stalenessTicks: 3000, invalidationTriggers: new[] { "StorytellerEvent" },
+                }, ownerMod: ModId, stalenessTicks: 3000, invalidationTriggers: new[] { StorytellerStateChangedEvent.EventName },
                 cacheScope: CacheScope.Scenario));
         }
 

Source/Storyteller/StorytellerRequestCoordinator.cs

@@ -1,6 +1,5 @@
 using System;
 using System.Linq;
-using RimMind.Application.Features.Llm;
 using RimMind.Domain.Llm;
 using RimMind.Domain.ValueObjects;
 using RimMind.Presentation.Api;
@@ -76,7 +75,7 @@
             if (target is not Map)
                 return false;
 
             if (!RimMindAPI.IsConfigured())
             {
                 RimMindErrors.Warn(
                     "[RimMind-Storyteller] ForceRequest: API not configured");
@@ -98,7 +97,7 @@
                     _memory.PeekReactions(20);
                     if (forced)
                     {
-                        RimMindAPI.ClearModCooldown("Storyteller");
+                        RimMindAPI.ClearModCooldown(StorytellerRequestIds.RequestModId);
                         Log.Message(
                             "[RimMind-Storyteller] ForceRequest: sending structured AI request");
                     }
@@ -124,14 +123,10 @@
             IIncidentTarget target,
             long requestToken)
         {
-            var envelope = LlmRequestEnvelopeBuilder
-                .ForScenario(RimMindAPI.Context.ScenarioStoryteller)
-                .WithModId("RimMind.Storyteller")
-                .WithSchema(RimMindAPI.Context.SchemaIncidentOutput)
-                .WithMaxTokens(400)
-                .WithTemperature(0.8f)
-                .WithNpcId(npcId)
-                .Build();
+            var envelope = StorytellerIncidentRequestFactory.Create(
+                RimMindAPI.Context.ScenarioStoryteller,
+                RimMindAPI.Context.SchemaIncidentOutput,
+                npcId);
 
             RimMindAPI.Request.Send(
                 envelope,

Source/Storyteller/StorytellerRequestIds.cs

@@ -0,0 +1,38 @@
+using RimMind.Application.Features.Llm;
+using RimMind.Domain.Llm;
+
+namespace RimMind.Storyteller
+{
+    /// <summary>
+    /// Storyteller-owned identity used by Core's request queue.
+    /// The same id must be passed to <c>LlmRequestEnvelopeBuilder.WithModId</c>, to
+    /// <c>RimMindAPI.ClearModCooldown</c> / <c>GetModCooldownTicksLeft</c>, and exposed by
+    /// <c>StorytellerModCooldown</c>: Core stores per-mod cooldowns under the envelope ModId,
+    /// so any other spelling silently targets a cooldown key that never exists.
+    /// </summary>
+    public static class StorytellerRequestIds
+    {
+        /// <summary>Envelope ModId and Core queue cooldown key for every Storyteller request.</summary>
+        public const string RequestModId = "RimMind.Storyteller";
+    }
+
+    /// <summary>
+    /// Builds the incident-selection envelope. Kept free of RimWorld state so the queue identity
+    /// can be verified outside the game.
+    /// </summary>
+    internal static class StorytellerIncidentRequestFactory
+    {
+        internal const int MaxTokens = 400;
+        internal const float Temperature = 0.8f;
+
+        internal static LlmRequestEnvelope Create(string scenarioId, string? schema, string npcId)
+            => LlmRequestEnvelopeBuilder
+                .ForScenario(scenarioId)
+                .WithModId(StorytellerRequestIds.RequestModId)
+                .WithSchema(schema)
+                .WithMaxTokens(MaxTokens)
+                .WithTemperature(Temperature)
+                .WithNpcId(npcId)
+                .Build();
+    }
+}

Source/Storyteller/StorytellerResponseParserPure.cs

@@ -2,6 +2,7 @@
 using System.Text.RegularExpressions;
 using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
+using RimMind.Application.Features.Json;
 
 namespace RimMind.Storyteller
 {
@@ -139,7 +140,7 @@ public static string ExtractJsonSubstring(string input)
             }
             catch
             {
-                return Repair(clean);
+                return JsonRepairer.TryRepairTruncatedJson(clean) ?? Repair(clean);
             }
         }
 

Source/Storyteller/StorytellerStateChangedEvent.cs

@@ -0,0 +1,32 @@
+using System;
+using RimMind.Domain.Events;
+using RimMind.Domain.ValueObjects;
+using RimMind.Presentation.Api;
+
+namespace RimMind.Storyteller
+{
+    /// <summary>
+    /// Published on the Core bus when storyteller state that feeds context changes (player chat
+    /// turns, incidents, tension). The cached storyteller context keys name <see cref="EventName"/>
+    /// as their invalidation trigger.
+    /// </summary>
+    public sealed class StorytellerStateChangedEvent : AgentBusEvent
+    {
+        /// <summary>Bus event name used by context-key invalidation triggers.</summary>
+        public const string EventName = "StorytellerEvent";
+
+        /// <summary>Registers <see cref="EventName"/> with the Core bus. Call before registering context keys.</summary>
+        internal static void Register()
+        {
+            try { RimMindAPI.Bus.RegisterEventType<StorytellerStateChangedEvent>(EventName); }
+            catch (Exception ex) { RimMindErrors.Warn($"[RimMind-Storyteller] Event type registration failed: {ex.Message}"); }
+        }
+
+        /// <summary>Publishes from any thread; never throws.</summary>
+        internal static void Publish()
+        {
+            try { RimMindAPI.Bus.PublishOnMainThread(new StorytellerStateChangedEvent()); }
+            catch (Exception ex) { RimMindErrors.Warn($"[RimMind-Storyteller] State change notification failed: {ex.Message}"); }
+        }
+    }
+}

Source/UI/Window_StorytellerDialogue.cs

@@ -201,7 +201,8 @@ private void SendMessage()
                         .AddSection("dialogue_input", userMsg)
                         .AddSection("IsStorytellerChat", "true"))
                 .ForScenarioId(ScenarioIds.Storyteller)
-                .WithModId("RimMind.Storyteller")
+                .WithModId(StorytellerRequestIds.RequestModId)
+                .WithHint("IsStorytellerChat", "true")
                 .WithMaxTokens(400)
                 .WithTemperature(0.9f)
                 .Build();
@@ -253,6 +254,8 @@ private static void RecordDialogueToMemory(string role, string content)
 
             int tick = Find.TickManager.TicksGame;
             memory.RecordDialogue(role, content, tick);
+            // storyteller_dialogue context is cached; the new turn must reach the next prompt.
+            StorytellerStateChangedEvent.Publish();
 
             TryPushToMemoryMod(role, content, tick);
         }

Tests/Contracts/StorytellerQueueIdentityContracts.cs

@@ -0,0 +1,61 @@
+using System;
+using System.IO;
+using System.Linq;
+using System.Text.RegularExpressions;
+using RimMind.Testing;
+using Xunit;
+
+namespace RimMind.Storyteller.Tests.Contracts
+{
+    /// <summary>
+    /// Regression contract for B7: the cooldown key cleared by a forced request must be the
+    /// envelope ModId Core uses to store the Storyteller queue cooldown.
+    /// </summary>
+    public sealed class StorytellerQueueIdentityContracts
+    {
+        [Fact]
+        public void Queue_cooldown_key_is_the_envelope_mod_id()
+        {
+            ContractCaseRunner.Run(
+                ("incident request envelope uses the module-owned request id", () =>
+                {
+                    var envelope = StorytellerIncidentRequestFactory.Create("Storyteller", "{}", "NPC-storyteller");
+                    Assert.Equal(StorytellerRequestIds.RequestModId, envelope.ModId);
+                    Assert.Equal("Storyteller", envelope.ScenarioId);
+                    Assert.Equal("NPC-storyteller", envelope.NpcId);
+                    Assert.Equal(StorytellerIncidentRequestFactory.MaxTokens, envelope.MaxTokens);
+                }),
+                ("source never clears or reads a cooldown with a literal key or diverging ModId", () =>
+                {
+                    var literalCooldownKey = new Regex(@"(ClearModCooldown|GetModCooldownTicksLeft)\(\s*""");
+                    var literalModId = new Regex(@"WithModId\(\s*""(?<id>[^""]*)""");
+                    string sourceRoot = SourceRoot();
+                    var files = Directory.EnumerateFiles(sourceRoot, "*.cs", SearchOption.AllDirectories)
+                        .Where(path => !path.Contains(Path.DirectorySeparatorChar + "obj" + Path.DirectorySeparatorChar))
+                        .ToList();
+                    Assert.NotEmpty(files);
+                    foreach (var file in files)
+                    {
+                        string text = File.ReadAllText(file);
+                        Assert.False(literalCooldownKey.IsMatch(text),
+                            $"{Path.GetFileName(file)} passes a literal cooldown key; use StorytellerRequestIds.RequestModId.");
+                        foreach (Match match in literalModId.Matches(text))
+                            Assert.Equal(StorytellerRequestIds.RequestModId, match.Groups["id"].Value);
+                    }
+                }));
+        }
+
+        private static string SourceRoot()
+        {
+            var directory = new DirectoryInfo(AppContext.BaseDirectory);
+            while (directory != null &&
+                   !Directory.Exists(Path.Combine(directory.FullName, "RimMind-Storyteller", "Source")))
+                directory = directory.Parent;
+
+            return Path.Combine(
+                directory?.FullName ?? throw new InvalidOperationException("Repository root not found."),
+                "RimMind-Storyteller",
+                "Source");
+        }
+    }
+}

Tests/RimMindStoryteller.Tests.csproj

@@ -31,12 +31,15 @@
     <Compile Include="../Source/Storyteller/StorytellerResponseParserPure.cs" LinkBase="Storyteller" />
     <Compile Include="../Source/Storyteller/IncidentSelectionPolicy.cs" LinkBase="Storyteller" />
     <Compile Include="../Source/Storyteller/StorytellerRequestState.cs" LinkBase="Storyteller" />
+    <Compile Include="../Source/Storyteller/StorytellerRequestIds.cs" LinkBase="Storyteller" />
+    <Compile Include="../Source/Storyteller/StorytellerStateChangedEvent.cs" LinkBase="Storyteller" />
     <Compile Include="../Source/Storyteller/StorytellerContextProviderRegistrar.cs" LinkBase="Storyteller" />
     <Compile Include="../Source/Storyteller/RimMindIncidentSelector.cs" LinkBase="Storyteller" />
     <Compile Include="../Source/Extensions/StorytellerContextBuilder.cs" LinkBase="Extensions" />
     <Compile Include="../Source/Extensions/PawnLookup.cs" LinkBase="Extensions" />
     <Compile Include="../Source/Extensions/PawnLookupCore.cs" LinkBase="Extensions" />
     <Compile Include="../Source/Extensions/StorytellerContextPolicy.cs" LinkBase="Extensions" />
+    <Compile Include="../../RimMind-Core/Source/Presentation/Common/RimMindText.cs" Link="Support/RimMindText.cs" />
   </ItemGroup>
 
   <ItemGroup>