rasa-pro 3.20.0.dev8__tar.gz → 3.20.0.dev9__tar.gz

{rasa_pro-3.20.0.dev8 → rasa_pro-3.20.0.dev9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: rasa-pro
-Version: 3.20.0.dev8
+Version: 3.20.0.dev9
 Summary: State-of-the-art open-core Conversational AI framework for Enterprises that natively leverages generative AI for effortless assistant development.
 Keywords: nlp,machine-learning,machine-learning-library,bot,bots,botkit,rasa conversational-agents,conversational-ai,chatbot,chatbot-framework,bot-framework
 Author: Rasa Technologies GmbH

{rasa_pro-3.20.0.dev8 → rasa_pro-3.20.0.dev9}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "rasa-pro"
-version = "3.20.0.dev8"
+version = "3.20.0.dev9"
 description = "State-of-the-art open-core Conversational AI framework for Enterprises that natively leverages generative AI for effortless assistant development."
 authors = [ "Rasa Technologies GmbH <hi@rasa.com>",]
 maintainers = [ "Tom Bocklisch <tom@rasa.com>",]
@@ -94,6 +94,10 @@ format = ["sdist", "wheel"]
 path = "rasa/mantle/default_skills/responses.yml"
 format = ["sdist", "wheel"]
 
+[[tool.poetry.include]]
+path = "rasa/mantle/orchestration/skill_completion/completion_judge_instruction.jinja2"
+format = ["sdist", "wheel"]
+
 [[tool.poetry.packages]]
 include = "rasa"
 

{rasa_pro-3.20.0.dev8 → rasa_pro-3.20.0.dev9}/rasa/builder/copilot/mcp_server/tools/event_ledger.py

@@ -237,8 +237,8 @@ def _to_single_line(text: str) -> str:
     return " ".join(text.split())
 
 
-def _short_value(value: Any, max_len: int = 80) -> str:
-    """Compact, single-line representation of a slot/reason value."""
+def _single_line_value(value: Any) -> str:
+    """Full single-line representation of a value, with no truncation."""
     if value is None:
         return "null"
     if isinstance(value, bool):
@@ -250,7 +250,12 @@ def _short_value(value: Any, max_len: int = 80) -> str:
         if isinstance(value, (list, dict))
         else str(value)
     )
-    rendered = _to_single_line(rendered)
+    return _to_single_line(rendered)
+
+
+def _short_value(value: Any, max_len: int = 80) -> str:
+    """Compact, single-line representation of a slot/reason value."""
+    rendered = _single_line_value(value)
     if len(rendered) > max_len:
         rendered = rendered[: max_len - 1] + "…"
     return rendered
@@ -579,7 +584,7 @@ def _format_debug_memory_event(event: Event) -> Optional[str]:
     if isinstance(event, MemoryCleared):
         return f"memory_cleared: {event.key}"
     if isinstance(event, MemorySet):
-        return f"memory_set: {event.key} = {_short_value(event.value)}"
+        return f"memory_set: {event.key} = {_single_line_value(event.value)}"
     return None
 
 
@@ -601,15 +606,15 @@ def _format_debug_ordered_block_event(event: _OrderedBlockEvent) -> str:
 
 
 def _format_debug_event_line(event: Event) -> str:
-    """Render one tracker event as a single debug line."""
+    """Render one tracker event as a single debug line, in full — no truncation."""
     if isinstance(event, UserUttered):
-        return f"user: {_short_value((event.text or '').strip(), 200)!r}"
+        return f"user: {_single_line_value((event.text or '').strip())!r}"
     if isinstance(event, BotUttered):
-        return f"agent: {_short_value((event.text or '').strip(), 200)!r}"
+        return f"agent: {_single_line_value((event.text or '').strip())!r}"
     if isinstance(event, ActionExecuted):
         return f"action: {event.action_name}"
     if isinstance(event, SlotSet):
-        return f"slot: {event.key} = {_short_value(event.value)}"
+        return f"slot: {event.key} = {_single_line_value(event.value)}"
     memory_line = _format_debug_memory_event(event)
     if memory_line is not None:
         return memory_line
@@ -629,9 +634,11 @@ def _format_debug_event_line(event: Event) -> str:
         flow_id = getattr(event, "flow_id", None)
         detail = agent_id or flow_id or ""
         return f"{event.type_name}: {detail}"
+    # Debug dump shows every event in full — unlike the compact ledger's
+    # `_short_value`, this must not truncate the payload.
     payload = event.as_dict()
     payload.pop("timestamp", None)
-    return f"{event.type_name}: {_short_value(payload, 120)}"
+    return f"{event.type_name}: {_single_line_value(payload)}"
 
 
 # ---------------------------------------------------------------------------

{rasa_pro-3.20.0.dev8 → rasa_pro-3.20.0.dev9}/rasa/builder/copilot/mcp_server/tools/text_simulation.py

@@ -419,6 +419,8 @@ async def _generate_user_message(
             Should be computed once via
             ``_user_simulator_completion_kwargs`` and reused for
             every turn.
+        conversation_id: Simulation conversation id for structured
+            debug logs.
         max_attempts: Number of retries on LLM call failures or
             unparseable responses before giving up.
 

{rasa_pro-3.20.0.dev8 → rasa_pro-3.20.0.dev9}/rasa/builder/evaluator/evaluators/classification/evaluator.py

@@ -34,7 +34,7 @@ class ClassificationEvaluator(BaseEvaluator):
 
         for item_result in item_results:
             output = item_result.output
-            expected = item_result.item.expected_output if item_result.item else None  # type: ignore[union-attr]
+            expected = item_result.item.expected_output if item_result.item else None  # type: ignore[union-attr, unused-ignore]
 
             if (
                 output is None

{rasa_pro-3.20.0.dev8 → rasa_pro-3.20.0.dev9}/rasa/cli/project_templates/mantle/AGENTS.md

@@ -56,7 +56,8 @@ common paths, this reference settles everything else.
 Read the page rather than guessing before you:
 
 - write a `skill.md` frontmatter key you have not already seen in this project
-- write a condition expression (`requires:`, `if:`, `complete_when:`, `next:`)
+- write a condition expression (`requires:`, `if:`, ordered-block step `complete_when:`, `next:`)
+- write skill-level frontmatter `complete_when` (mapping with `condition:` and/or `criteria:`, not a bare string)
 - write an `agent.yml`, `integrations.yml`, `memory.yml`, or `responses.yml` key
 - add a file or folder to the project
 - explain a `rasa train` error

{rasa_pro-3.20.0.dev8 → rasa_pro-3.20.0.dev9}/rasa/cli/tools/skills_data/mantle/mantle-building-skills/SKILL.md

@@ -240,17 +240,33 @@ the LLM respond (same as omitting that name).
 `requires:` is a **string** memory expression. The map form
 (`selected_card_id: { exists: true }`) is rejected.
 
-In **conditions** (`requires:`, `if:`, `complete_when:`, `utter:` `when:`, `next:`),
-every memory reference uses three segments: `session.<skill_id>.<entry>` for a
-skill's own memory, `session.project.<entry>` for project-wide memory. A bare key
-is rejected at validation with `Unknown name '<key>' in condition expression`, so
-`requires: selected_card_id` does not work. Within that form you can write a
-truthiness check (`session.card_replace.selected_card_id`), a boolean combination
+In **conditions** (`requires:`, `if:`, step-level `complete_when:`, `utter:`
+`when:`, `next:`), every memory reference uses three segments:
+`session.<skill_id>.<entry>` for a skill's own memory, `session.project.<entry>`
+for project-wide memory. A bare key is rejected at validation with
+`Unknown name '<key>' in condition expression`, so `requires: selected_card_id`
+does not work. Within that form you can write a truthiness check
+(`session.card_replace.selected_card_id`), a boolean combination
 (`session.card_replace.order_confirmed and session.card_replace.shipping_type`,
 `not session.card_replace.fraud_report_filed`), or a comparison
 (`session.card_replace.replacement_reason == 'stolen'`). Use a folded `>` scalar
 when the expression spans lines.
 
+Skill-level frontmatter `complete_when` is different: it must be a **mapping**
+with `condition` (one expression string, same grammar as `requires:`) and/or
+`criteria` (list of sentences in natural language, checked when `complete_skill` runs).
+A bare string is rejected. It requires prose instructions (not ordered-block-only
+skills). When `criteria` are present, prose auto-complete is disabled and exit
+goes through gated `complete_skill` only. Ordered-block step `complete_when:`
+stays a plain condition string.
+
+Write each `criteria` item as **one clear check** — something you can verify
+from what happened in the conversation (for example a tool ran, or the agent
+asked a required question). Prefer several short items over one long sentence
+that mixes duties with "and" / "or". Put memory logic in `condition:` instead.
+When a check fails, the error can point at that item so the agent knows what to
+fix next.
+
 A closed gate removes the tool from the LLM's schema, so it cannot call what it
 cannot see. Every key referenced must be declared in a `memory.yml` schema.
 `tool_constraints` are enforced no matter who triggers the tool, the LLM or an
@@ -323,8 +339,12 @@ Exact wording the LLM never touches. Declare triggers in frontmatter; put text i
 
 - **`on: activate`** — fires once when the **owning skill** is activated (routing
   into the skill). Does not fire on ordered-block entry or interrupt resume within
-  the same skill.
-- **`when:`** — a condition expression, same syntax as `requires:` /
+  the same skill. Variant selection runs **after** that skill's memory is reset
+  for the new run, so CRVs that read the skill's own fields see `initial_value`
+  (or `null`) and usually deliver the **default** variant. Prefer **project
+  memory** or a matching skill-field `initial_value` for activation wording;
+  use **`when:`** when the value is written after the skill starts.
+- **`when:`** — a condition expression, same syntax as `requires:` / step-level
   `complete_when:` (memory as `session.<skill_id>.<entry>`). Fires **once** when the
   condition **first becomes true** after a memory write — not on every turn it
   still holds.
@@ -485,9 +505,15 @@ block resumes at the same step.
   `requires`, `complete_when`, `import_tools`, `tool_constraints`, `utter`, and
   `disabled`. Unknown keys are ignored rather than rejected, so a typo silently
   does nothing.
+- Don't use a bare string for skill-level `complete_when`. Frontmatter must be a
+  mapping with `condition:` (expression string) and/or `criteria:` (list; see
+  above). Prefer one clear check per `criteria` item; duplicate strings are
+  rejected. Ordered-block step `complete_when:` stays a plain condition string.
+  Don't put skill-level `complete_when` on ordered-block-only skills (needs prose
+  / `complete_skill`).
 - Don't use a bare memory key in any **condition**. `requires:`, `if:`,
-  `complete_when:`, `utter:` `when:`, and `next:` branches all take the same
-  three-segment form: `session.<skill_id>.<entry>` or `session.project.<entry>`.
+  step-level `complete_when:`, `utter:` `when:`, and `next:` branches all take the
+  same three-segment form: `session.<skill_id>.<entry>` or `session.project.<entry>`.
 - Don't put bare `session.*` in free instruction prose — use `@memory.…` for live
   values there (see "Memory in prose").
 - Don't treat `rasa train` as optional. It is the validation gate for undeclared
@@ -503,8 +529,8 @@ project has no `AGENTS.md`. Never read `llms-full.txt` whole; it is ~250 KB.
 Most relevant here — read the page rather than guessing:
 
 - `/reference/project-structure` — Project structure: where a skill folder sits and what may live in it
-- `/reference/skill-md` — skill.md reference: frontmatter properties, body format, jump tokens
-- `/reference/conditions` — Conditions: the expression grammar for requires:, if:, complete_when:, next:
+- `/reference/skill-md` — skill.md reference: frontmatter (incl. skill-level `complete_when` mapping), body format, jump tokens
+- `/reference/conditions` — Conditions: the expression grammar for requires:, if:, step-level complete_when:, next:
 - `/reference/ordered-block-steps` — Ordered block steps: step kinds, step fields, branching
 - `/reference/tools` — Tools reference: ToolContext, ToolResult, gating, post-write hooks, cancellation
 - `/reference/memory-yml` — memory.yml reference: scopes, types, visibility, access control

{rasa_pro-3.20.0.dev8 → rasa_pro-3.20.0.dev9}/rasa/cli/tools/skills_data/mantle/mantle-configuring-agent/SKILL.md

@@ -11,7 +11,7 @@ engine: mantle
 rasa_version: ">=3.18"
 metadata:
   author: rasa
-  version: "0.1.11"
+  version: "0.1.12"
   docs-url: https://rasa-2f7eb63d.mintlify.site
 ---
 
@@ -25,7 +25,7 @@ my-agent/
 ├── integrations.yml       # Required. LLM model groups, channels, optional tracing
 ├── memory.yml             # Optional. Project-wide shared memory
 ├── responses.yml          # Optional. Project-wide responses, overrides built-in wording
-├── references/            # Optional. Agent-wide knowledge, every **/*.md is indexed
+├── references/            # Optional. Agent-wide knowledge; **/*.md is chunked at train
 ├── tools/                 # Optional. Shared tools, declared with import_tools
 └── skills/
     └── <skill>/           # The folder name is the skill id
@@ -222,20 +222,33 @@ model_groups:
 ```yaml agent.yml
 references:
   embeddings: reference_embeddings
+  chunking:
+    chunk_size: 1000
+    chunk_overlap: 20
 ```
 
 The orchestrator group is read from the live project, so changing it needs a
 restart. Embeddings groups are read from the packaged snapshot, so changing the
-embedding model needs a retrain.
+embedding model needs a retrain. Changing `references.chunking` also needs a
+retrain.
 
 ## Knowledge (RAG)
 
-There is no config for this. Put markdown files in a `references/` folder, at the
-agent root or inside a skill, and `rasa train` indexes every `**/*.md` into the
-model. The agent then gets the built-in `search_knowledge` tool automatically.
+Put markdown files in a `references/` folder, at the agent root or inside a
+skill. At `rasa train`, every `**/*.md` is split into overlapping character
+chunks and embedded. The agent then gets the built-in `search_knowledge` tool.
+Hits are **sections of the file**, not the whole document. A large FAQ can stay
+in one file; you do not need to split it by hand.
+
+Omit `chunking` to use defaults (`chunk_size: 1000`, `chunk_overlap: 20`). Those
+values are **characters**, not embedding tokens. Overlap must be smaller than
+size; unknown keys under `chunking` fail the load. Keep `chunk_size` well under
+the embedder input limit (8192 tokens on Azure OpenAI embeddings and OpenAI
+`text-embedding-3-*`).
 
 Both locations feed one index, and a search covers all of it whatever skill is
-active, so write each document to stand on its own.
+active, so write each document to stand on its own. Full field table:
+`/reference/agent-yml`. Retrieval flow: `/concepts/references`.
 
 ## memory.yml — state schema
 
@@ -349,6 +362,10 @@ This is different from a skill `utter:` trigger with `when:` in `skill.md`:
 (action step, collect ask, tool outcome, confirmation prompt, `on: activate`,
 etc.) resolves that response name. Both use the same
 [condition expression grammar](https://rasa-2f7eb63d.mintlify.site/reference/conditions).
+Note: `on: activate` selects variants **after** the skill's memory is reset for
+the new run, so CRVs on that skill's own fields usually fall through to the
+default unless you use project memory, a matching `initial_value`, or a `when:`
+trigger for values written after activation.
 
 Only `text`, `metadata`, `condition`, and `buttons:` are permitted on a variant.
 `channel:` is not supported. `metadata.rephrase: true` applies to
@@ -412,7 +429,8 @@ project has no `AGENTS.md`. Never read `llms-full.txt` whole; it is ~250 KB.
 Most relevant here — read the page rather than guessing:
 
 - `/reference/project-structure` — Project structure: every file and folder an agent recognises, and which are required
-- `/reference/agent-yml` — agent.yml reference: every key, and which are top-level rather than nested
+- `/reference/agent-yml` — agent.yml reference: every key, including `references.chunking`, and which are top-level rather than nested
+- `/concepts/references` — References: index-time chunking and `search_knowledge`
 - `/reference/integrations-yml` — integrations.yml reference: LLM providers, channels, voice ASR/TTS, model groups, MCP servers
 - `/concepts/tools` — Import MCP tools (see its MCP tools section): declare a server, then allowlist tools with `import_tools`
 - `/reference/memory-yml` — memory.yml reference: skill schema vs project memory, types, access control

{rasa_pro-3.20.0.dev8 → rasa_pro-3.20.0.dev9}/rasa/cli/tools/skills_data/mantle/mantle-docs/SKILL.md

@@ -12,7 +12,7 @@ engine: mantle
 rasa_version: ">=3.18"
 metadata:
   author: rasa
-  version: "0.1.3"
+  version: "0.1.4"
   docs-url: https://rasa-2f7eb63d.mintlify.site
 ---
 
@@ -76,7 +76,7 @@ shipped.
 - `/concepts/instructions` — Instructions: The plain-language body of a skill
 - `/concepts/tools` — Tools: Typed functions a skill can call
 - `/concepts/memory` — Memory: Values a skill tracks across a conversation
-- `/concepts/references` — References: Knowledge the agent answers questions from
+- `/concepts/references` — References: Knowledge the agent answers questions from (chunked at train time)
 - `/concepts/responses` — Responses: Verbatim wording the LLM never rewrites
 
 **Progressive Control**
@@ -97,9 +97,9 @@ shipped.
 **Reference**
 
 - `/reference/project-structure` — Project structure: Every file and folder an agent recognises, and which are required
-- `/reference/conditions` — Conditions: The memory expression language used by requires:, if:, complete_when:, next:
-- `/reference/skill-md` — skill.md: Frontmatter properties and body format
-- `/reference/agent-yml` — agent.yml: Identity, persona, rules, prompt tuning
+- `/reference/conditions` — Conditions: The memory expression language used by requires:, if:, ordered-block step complete_when:, next:
+- `/reference/skill-md` — skill.md: Frontmatter properties and body format (incl. skill-level complete_when mapping)
+- `/reference/agent-yml` — agent.yml: Identity, persona, rules, prompt tuning, references.chunking
 - `/reference/integrations-yml` — integrations.yml: LLM provider, channels, voice ASR/TTS, Langfuse tracing
 - `/reference/memory-yml` — memory.yml: Memory schema, types, visibility
 - `/reference/responses-yml` — responses.yml: Response templates and interpolation

{rasa_pro-3.20.0.dev8 → rasa_pro-3.20.0.dev9}/rasa/cli/tools/skills_data/mantle/mantle-testing-debugging/SKILL.md

@@ -10,7 +10,7 @@ engine: mantle
 rasa_version: ">=3.18"
 metadata:
   author: rasa
-  version: "0.1.8"
+  version: "0.1.9"
   docs-url: https://rasa-2f7eb63d.mintlify.site
 ---
 
@@ -152,6 +152,13 @@ Frequent causes:
   (`config.agent.missing_section` / `config.agent.missing_persona`)
 - an unquoted colon in an `agent.yml` `rules:` item (quote it or use a `>` folded
   scalar)
+- `references.chunking` with `chunk_size` ≤ 0, `chunk_overlap` ≥ `chunk_size`, or
+  an unknown key under `chunking`
+- `rasa train` failing with an embedding token / context-window error (a chunk
+  exceeded the embedder input limit — lower `chunk_size`, which is characters,
+  and retrain)
+- knowledge answers quoting a whole FAQ after you changed `references/` or
+  `chunking` — serving uses the packaged index; re-run `rasa train`
 
 Unknown frontmatter keys are ignored rather than rejected, so a typo produces no
 error and no effect. Check the spelling against the `skill.md` reference.
@@ -185,3 +192,4 @@ Most relevant here — read the page rather than guessing:
 - `/reference/prompt-templates` — Prompt templates: the assembled prompt and the framework tools offered per situation
 - `/reference/tools` — Tools reference: why a tool may not appear in the schema
 - `/reference/responses-yml` — responses.yml reference: conditional variants, static buttons, and train-time validation
+- `/concepts/references` — References: chunking at train time and section-level `search_knowledge` hits

{rasa_pro-3.20.0.dev8 → rasa_pro-3.20.0.dev9}/rasa/mantle/config/agent_spec.py

@@ -20,6 +20,10 @@ import structlog
 from duoname import duoname
 from pydantic import BaseModel, ConfigDict, Field, model_validator
 
+from rasa.core.information_retrieval.faiss import (
+    DEFAULT_CHUNK_OVERLAP,
+    DEFAULT_CHUNK_SIZE,
+)
 from rasa.exceptions import ValidationError
 from rasa.shared.utils.yaml import read_yaml_file, write_yaml
 
@@ -118,6 +122,25 @@ class AgentVoiceConfig(BaseModel):
     tts: str = ""
 
 
+class ReferenceChunkingConfig(BaseModel):
+    """Configure how reference documents are split before embedding."""
+
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    chunk_size: int = Field(default=DEFAULT_CHUNK_SIZE, gt=0)
+    """Maximum number of characters in a reference chunk."""
+
+    chunk_overlap: int = Field(default=DEFAULT_CHUNK_OVERLAP, ge=0)
+    """Number of characters shared by adjacent reference chunks."""
+
+    @model_validator(mode="after")
+    def validate_chunk_overlap(self) -> "ReferenceChunkingConfig":
+        """Ensure overlap leaves room for new content in each chunk."""
+        if self.chunk_overlap >= self.chunk_size:
+            raise ValueError("`chunk_overlap` must be smaller than `chunk_size`.")
+        return self
+
+
 class ReferencesConfig(BaseModel):
     """Answering guidance for knowledge questions from the ``references`` section.
 
@@ -137,6 +160,9 @@ class ReferencesConfig(BaseModel):
     reference files. Empty → the built-in default embeddings (OpenAI), like
     ``EnterpriseSearchPolicy``."""
 
+    chunking: ReferenceChunkingConfig = ReferenceChunkingConfig()
+    """Index-time recursive character chunking configuration."""
+
 
 class AgentSpec(BaseModel):
     """User-authored agent identity parsed from the `agent.yml`."""

rasa_pro-3.20.0.dev8/rasa/mantle/skills/responses_validation.py → rasa_pro-3.20.0.dev9/rasa/mantle/content/validation.py

@@ -4,7 +4,7 @@ Project validation loads each ``responses.yml`` leniently: unknown variant keys
 and other parse problems become
 :class:`~rasa.mantle.validation_finding.ValidationFinding` entries so every
 project file is checked. Runtime model load still uses strict
-:meth:`~rasa.mantle.skills.responses.ResponseRegistry.from_yaml`, which raises
+:meth:`~rasa.mantle.content.responses.ResponseRegistry.from_yaml`, which raises
 on the first parse error.
 
 This module also validates parsed variant shape: non-empty text, condition
@@ -15,11 +15,34 @@ rules.
 from __future__ import annotations
 
 from collections.abc import Callable, Iterable, Iterator, Mapping
+from functools import partial
 from pathlib import Path
 from typing import NamedTuple
 
 import yaml  # type: ignore[import-untyped]
 
+from rasa.mantle.content.responses import (
+    ALLOWED_BUTTON_KEYS,
+    ALLOWED_VARIANT_KEYS,
+    METADATA_REPHRASE_KEY,
+    RESPONSES_FILENAME,
+    RESPONSES_YAML_KEY,
+    VARIANT_BUTTONS_KEY,
+    VARIANT_CONDITION_KEY,
+    VARIANT_METADATA_KEY,
+    VARIANT_TEXT_KEY,
+    RegisteredResponse,
+    ResponseButton,
+    ResponseDefinition,
+    ResponseRegistry,
+)
+from rasa.mantle.content.static_buttons import (
+    SetMemoryPayloadError,
+    button_writable_memory_keys_for_skill,
+    coerce_set_memory_button_value,
+    is_set_memory_payload,
+    parse_static_set_memory_payload,
+)
 from rasa.mantle.memory.field import (
     MEMORY_FIELD_TYPE_BOOL,
     MEMORY_FIELD_TYPE_CATEGORICAL,
@@ -36,7 +59,7 @@ from rasa.mantle.memory.manager import (
 )
 from rasa.mantle.memory.schema import ProjectMemorySchema
 from rasa.mantle.model_archive.bootstrap import load_bundled_response_registry
-from rasa.mantle.skills.catalog import SkillCatalog
+from rasa.mantle.skills.catalog import SkillCatalog, SkillDefinition, SkillFlow
 from rasa.mantle.skills.conditions import (
     ConditionEvaluationError,
     GatedTool,
@@ -44,29 +67,7 @@ from rasa.mantle.skills.conditions import (
     validate_condition_syntax,
 )
 from rasa.mantle.skills.prose_scoping import is_empty_prose_if_condition
-from rasa.mantle.skills.response_buttons import (
-    SetMemoryPayloadError,
-    button_writable_memory_keys_for_skill,
-    coerce_set_memory_button_value,
-    is_set_memory_payload,
-    parse_static_set_memory_payload,
-)
-from rasa.mantle.skills.responses import (
-    ALLOWED_BUTTON_KEYS,
-    ALLOWED_VARIANT_KEYS,
-    METADATA_REPHRASE_KEY,
-    RESPONSES_FILENAME,
-    RESPONSES_YAML_KEY,
-    VARIANT_BUTTONS_KEY,
-    VARIANT_CONDITION_KEY,
-    VARIANT_METADATA_KEY,
-    VARIANT_TEXT_KEY,
-    RegisteredResponse,
-    ResponseButton,
-    ResponseDefinition,
-    ResponseRegistry,
-)
-from rasa.mantle.skills.steps import ActionStep, CollectStep
+from rasa.mantle.skills.steps import ActionStep, CollectStep, Step
 from rasa.mantle.validation_finding import ValidationFinding
 from rasa.shared.constants import UTTER_PREFIX
 from rasa.shared.project_structure import V2_SKILLS_DIR
@@ -959,7 +960,6 @@ def _memory_keys_readable_for_responses(
     """
     return _memory_keys_for_responses_file(
         catalog,
-        project_memory,
         observing_skill_id,
         per_skill=lambda skill_id: readable_memory_slot_names(
             catalog, project_memory, skill_id
@@ -972,7 +972,6 @@ def _memory_keys_readable_for_responses(
 
 def _memory_keys_for_responses_file(
     catalog: SkillCatalog,
-    project_memory: ProjectMemorySchema,
     observing_skill_id: str | None,
     *,
     per_skill: Callable[[str], frozenset[str]],
@@ -1065,27 +1064,60 @@ def _skills_referencing_responses(
 ) -> dict[str, frozenset[str]]:
     """Map each ``utter_*`` response name to skill ids that reference it."""
     users: dict[str, set[str]] = {}
+    for skill in catalog.skills.values():
+        _collect_skill_response_refs(skill, users)
+    return {name: frozenset(skill_ids) for name, skill_ids in users.items()}
 
-    def _add(response_name: str | None, skill_id: str) -> None:
-        if response_name is None or not response_name.startswith(UTTER_PREFIX):
-            return
-        users.setdefault(response_name, set()).add(skill_id)
 
-    for skill in catalog.skills.values():
-        for flow in skill.flows:
-            for step in flow.steps:
-                if isinstance(step, ActionStep):
-                    _add(step.action, skill.id)
-                elif isinstance(step, CollectStep):
-                    _add(step.utterance, skill.id)
-            for gate in flow.tools:
-                _add_gated_tool_response_refs(gate, skill.id, _add)
-        for gate in skill.logic.tools:
-            _add_gated_tool_response_refs(gate, skill.id, _add)
-        for trigger in skill.logic.verbatim_triggers:
-            _add(trigger.response_name, skill.id)
+def _record_response_user(
+    users: dict[str, set[str]],
+    response_name: str | None,
+    skill_id: str,
+) -> None:
+    """Add *skill_id* as a user of *response_name* when it is an ``utter_*``."""
+    if response_name is None or not response_name.startswith(UTTER_PREFIX):
+        return
+    users.setdefault(response_name, set()).add(skill_id)
 
-    return {name: frozenset(skill_ids) for name, skill_ids in users.items()}
+
+def _collect_skill_response_refs(
+    skill: SkillDefinition,
+    users: dict[str, set[str]],
+) -> None:
+    """Record ``utter_*`` references from one skill onto *users*."""
+    skill_id = skill.id
+    add = partial(_record_response_user, users)
+    for flow in skill.flows:
+        _collect_flow_response_refs(flow, skill_id, add)
+    for gate in skill.logic.tools:
+        _add_gated_tool_response_refs(gate, skill_id, add)
+    for trigger in skill.logic.verbatim_triggers:
+        add(trigger.response_name, skill_id)
+
+
+def _collect_flow_response_refs(
+    flow: SkillFlow,
+    skill_id: str,
+    add: Callable[[str | None, str], None],
+) -> None:
+    """Record ``utter_*`` references from one flow's steps and tool gates."""
+    for step in flow.steps:
+        _collect_step_response_ref(step, skill_id, add)
+    for gate in flow.tools:
+        _add_gated_tool_response_refs(gate, skill_id, add)
+
+
+def _collect_step_response_ref(
+    step: Step,
+    skill_id: str,
+    add: Callable[[str | None, str], None],
+) -> None:
+    """Record an ``utter_*`` reference from an action or collect step, if any."""
+    if isinstance(step, ActionStep):
+        add(step.action, skill_id)
+        return
+    if isinstance(step, CollectStep):
+        add(step.utterance, skill_id)
 
 
 def _add_gated_tool_response_refs(