fix(prompts): memory instruction now reaches native tool-calling roles (4.12.1)

AiToolContractPromptFormatter appended the positive memory-usage guidance AFTER the
supportsNativeToolCalling early-return, so native tool-calling roles whose base prompt never mentions
memory (e.g. Creator) received no memory instruction at all and ignored "remember the ..." tasks —
leaving persistence to whether the model happened to infer it. Move the memory-tool detection and a
strengthened imperative ahead of the early-return so both native and text-shaped paths get it (gated on
the role actually having the memory tool).

Validated by the live MultiAgentCraftingWorkflowPlayModeTests run: Creator now reliably persists the
design summary (previously empty -> test failed). Adds DeterministicToolContractEditModeTests coverage
(native+memory includes the imperative; native without memory omits it). Lockstep bump coreai +
coreaiunity to 4.12.1.

Author: NeoXider

Assets/CoreAI/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 ## [Unreleased]
 
+## 4.12.1 - 2026-06-28
+
+- **fix(prompts): memory-usage instruction now reaches native tool-calling roles.** In
+  `AiToolContractPromptFormatter`, the positive memory guidance ("when asked to remember/save/record,
+  call the memory tool") lived *after* the `supportsNativeToolCalling` early-return, so native
+  tool-calling roles whose base prompt never mentions memory (e.g. Creator) received **no** memory
+  instruction at all and silently ignored "remember the …" tasks — leaving it to the model to infer.
+  The detection + a strengthened imperative now run ahead of the early-return, so both the native and
+  text-shaped paths get it (gated on the role actually having the `memory` tool). Tests:
+  `DeterministicToolContractEditModeTests` (native+memory includes the imperative; native without memory
+  omits it).
+
 ## 4.12.0 - 2026-06-28
 
 - **Lua mod versioning (`manage_mods versions` / `revert`).** Mod load/reload now records a revision per

Assets/CoreAI/Runtime/Core/Features/Orchestration/AiToolContractPromptFormatter.cs

@@ -44,14 +44,8 @@ public static string AppendToolContract(
                 sb.AppendLine(extra);
             }
 
-            if (supportsNativeToolCalling)
-            {
-                AppendForcedToolInstruction(sb, task);
-                return sb.ToString();
-            }
-
-            bool hasMemoryTool = false;
             IReadOnlyList<ILlmTool> canonicalTools = AiToolOrder.Canonical(tools);
+            bool hasMemoryTool = false;
             foreach (ILlmTool tool in canonicalTools)
             {
                 if (tool != null &&
@@ -62,6 +56,24 @@ public static string AppendToolContract(
                 }
             }
 
+            // Positive memory trigger — applies to BOTH native and text-shaped tool-calling. Without it a role
+            // whose base prompt never mentions memory (e.g. Creator) silently ignores "remember the ..." because
+            // nothing maps that soft verb to the memory tool. This guidance previously lived only AFTER the
+            // native early-return below, so native tool-calling roles received no memory instruction at all.
+            if (hasMemoryTool)
+            {
+                sb.AppendLine(
+                    "Memory: when the task asks you to remember, save, note, record, or persist something, you MUST " +
+                    "call the memory tool (action \"append\" or \"store\") to persist it before answering — prose or " +
+                    "reasoning alone never saves anything.");
+            }
+
+            if (supportsNativeToolCalling)
+            {
+                AppendForcedToolInstruction(sb, task);
+                return sb.ToString();
+            }
+
             if (hasMemoryTool)
             {
                 sb.AppendLine(

Assets/CoreAI/package.json

@@ -1,6 +1,6 @@
 {
   "name": "com.neoxider.coreai",
-  "version": "4.12.0",
+  "version": "4.12.1",
   "displayName": "CoreAI",
   "unity": "6000.0",
   "description": "Portable C# core for CoreAI — LLM agents that call your game code. Orchestration, function-calling tools, agent memory, AgentBuilder, SkillSet, and production resilience (retries, timeouts, rate limits), with no UnityEngine dependency. LLM and Lua are optional modules (COREAI_NO_LLM / COREAI_NO_LUA), so the core compiles without them — install only what your game uses. Unity integration ships in com.neoxider.coreaiunity.",

Assets/CoreAiUnity/CHANGELOG.md

@@ -4,6 +4,16 @@ Unity host: **CoreAI.Source** build, EditMode / PlayMode tests, Editor menus, do
 
 ## [Unreleased]
 
+## 4.12.1 - 2026-06-28
+
+Depends on **`com.neoxider.coreai` 4.12.1** (native-role memory-instruction fix).
+
+- **fix(prompts): native tool-calling roles with the memory tool now get the memory instruction.**
+  See the Core 4.12.1 entry — the guidance was gated behind the native early-return in
+  `AiToolContractPromptFormatter`, so a role like Creator ignored "remember the …" tasks. Validated by the
+  live multi-agent crafting workflow (`MultiAgentCraftingWorkflowPlayModeTests`): Creator now reliably
+  persists the design summary. Lockstep version bump.
+
 ## 4.12.0 - 2026-06-28
 
 Depends on **`com.neoxider.coreai` 4.12.0** (Lua mod versioning + runtime handler-error diagnostics).

Assets/CoreAiUnity/Tests/EditMode/DeterministicToolContractEditModeTests.cs

@@ -86,6 +86,37 @@ public async Task BuildRequest_FixedInputs_ProduceIdenticalSystemPrefixWithoutGe
             AssertNoGuidOrTimestamp(first);
         }
 
+        [Test]
+        public void AppendToolContract_NativeToolCallingWithMemoryTool_IncludesMemoryImperative()
+        {
+            // Regression: the memory instruction used to live only on the text-shaped path, after the
+            // native early-return, so native tool-calling roles (e.g. Creator) got no memory guidance and
+            // ignored "remember the ..." tasks.
+            string native = AiToolContractPromptFormatter.AppendToolContract(
+                "sys",
+                new[] { new StubTool("memory") },
+                new AiTaskRequest { RoleId = "Creator" },
+                new TestSettings(),
+                supportsNativeToolCalling: true);
+
+            StringAssert.Contains("call the memory tool", native,
+                "Native tool-calling roles with the memory tool must receive the positive memory instruction.");
+        }
+
+        [Test]
+        public void AppendToolContract_NativeToolCallingWithoutMemoryTool_OmitsMemoryImperative()
+        {
+            string native = AiToolContractPromptFormatter.AppendToolContract(
+                "sys",
+                new[] { new StubTool("world_command") },
+                new AiTaskRequest { RoleId = "Creator" },
+                new TestSettings(),
+                supportsNativeToolCalling: true);
+
+            StringAssert.DoesNotContain("call the memory tool", native,
+                "Roles without the memory tool must not receive memory guidance.");
+        }
+
         private static AgentMemoryPolicy BuildPolicy(params ILlmTool[] tools)
         {
             AgentMemoryPolicy policy = new();

Assets/CoreAiUnity/package.json

@@ -1,6 +1,6 @@
 {
   "name": "com.neoxider.coreaiunity",
-  "version": "4.12.0",
+  "version": "4.12.1",
   "displayName": "CoreAI Unity",
   "unity": "6000.0",
   "description": "Unity framework for LLM-powered NPCs and agents that call your game code — drop-in chat UI, function-calling tools, persistent memory, token-by-token streaming, and per-role LLM routing. Runs on a local GGUF model (via LLMUnity) or any OpenAI-compatible API; proven on a 4 GB local model. Unity layer for com.neoxider.coreai.",
@@ -9,6 +9,6 @@
     "url": "https://github.com/NeoXider/CoreAI"
   },
   "dependencies": {
-    "com.neoxider.coreai": "4.12.0"
+    "com.neoxider.coreai": "4.12.1"
   }
 }