Reading and ingestion of stories and bugs
These six skills are the entry point of almost any QA flow: they normalize a
user story or a reported bug — whether it comes from a local file, from Jira, or from Azure DevOps — into
a common data structure that the rest of the skills can consume without wondering where it
came from. The sixth one, lippia-neo-read-test-plan, does the same with a test plan already written to
disk.
None of them writes to disk when the source is remote
Content fetched from Jira/Azure DevOps is always kept in memory; it's never persisted to the local stories directory.
lippia-neo-read-user-story
When to use it
When starting a QA flow on a user story. It receives a reference — a local path
to a .md file or the URL of a ticket (Jira / Azure DevOps) — resolves it automatically, and extracts
the summary, the acceptance criteria, the app URL, the test credentials, and the
key features to test. It's the standard entry point of any story-based flow
(the counterpart of lippia-neo-read-bug-report for bugs).
{
"input": {
"user_story": "user-stories/PA-US-02.md"
}
}
| Input | Type | Description |
|---|---|---|
input.user_story |
Required | Local path to a .md file or URL of a remote ticket; it's never hardcoded. A path is always read from disk (also trying it relative to paths.user_stories_storage.local_path); a URL is only processed if its provider matches paths.user_stories_storage.cloud_provider_mcp in qa-stack.yaml and its host matches the instance configured in .mcp.json — otherwise, the skill stops. |
input.user_story_ref |
Optional | Explicit alias of the reference, if input.user_story isn't used. |
input.identifier |
Optional | Identifier already resolved by the caller; it takes priority over the us_id derived from the story. |
input.jira_content / input.jira_source_url |
Optional | Content already fetched by lippia-neo-fetch-jira-user-story (typical of an M2/M4 plan that has already resolved the source); if present, it takes priority over input.user_story. |
input.azure_content / input.azure_source_url |
Optional | Same criterion, for content already fetched from Azure DevOps. |
Output
| Field | Description |
|---|---|
us_id / identifier |
Short identifier of the story, and its normalized alias. |
summary |
Summary of the story. |
acceptance_criteria |
List of acceptance criteria. |
app_urls |
URL(s) of the app under test. |
credentials |
Referenced test credentials. |
key_features |
Key features to test. |
source_kind |
local_path | jira | azure-devops. |
user_story_path / source_url |
Local path or URL of the source ticket, depending on source_kind. |
can_continue |
true if there was enough context to summarize with confidence; null if not (never false). |
Chains with
First step of any story-based flow (lippia-neo-workflow-e2e, M2/M4 plans). For remote
URLs, it dispatches to lippia-neo-fetch-jira-user-story / lippia-neo-fetch-azure-user-story. It continues with
lippia-neo-create-test-plan → lippia-neo-scripted-execution → lippia-neo-generate-test-suite → lippia-neo-run-and-heal →
lippia-neo-write-test-report.
lippia-neo-fetch-jira-user-story
Subskill of lippia-neo-read-user-story
You don't need to invoke it directly: you invoke lippia-neo-read-user-story and this subskill is chosen automatically when you pass it the URL or key of a Jira issue.
When to use it
When QA work needs to start from a Jira Cloud issue instead of a local .md
file. It fetches the issue via the Atlassian MCP and, if it links to Confluence pages, fetches them
too and enriches the content with that spec (goal, context, acceptance criteria,
technical info). It returns everything structured in memory, ready for
lippia-neo-read-user-story (or lippia-neo-workflow-e2e) to consume directly. It accepts
a bare key (TS-42), a Jira URL, or the slash command argument.
{
"input": {
"jira_issue_ref": "https://your-site.atlassian.net/browse/TS-42"
}
}
| Input | Type | Description |
|---|---|---|
input.jira_issue_ref |
Required | Key or URL of the issue; the skill extracts the canonical key. |
input.jira_issue_key |
Optional | Explicit alias, if you already have the bare key (e.g. TS-42). |
Output
| Field | Description |
|---|---|
jira_issue_key |
Key of the issue, for traceability. |
content |
Full content in canonical format, in memory, ready for lippia-neo-read-user-story. |
source_url |
Canonical URL of the issue. |
title / issue_type / status |
Summary, type (Story/Bug/Task/…), and status of the issue. |
ac_source |
Where the acceptance criteria came from (custom_field | description | confluence | none). |
confluence_pages |
Fetched Confluence pages (page_id, title, url). |
summary |
Readable summary of the operation. |
warnings |
Warnings (e.g. empty description, Confluence MCP not available). |
Chains with
Runs before lippia-neo-read-user-story (step 1 of lippia-neo-workflow-e2e). It never writes to the
local stories directory. In qa-stack.yaml you can adjust jira.acceptance_criteria_field
(custom field where the AC live) and jira.follow_confluence_links (default true; with false
it doesn't follow the links to Confluence).
lippia-neo-fetch-azure-user-story
Subskill of lippia-neo-read-user-story
You don't need to invoke it directly: you invoke lippia-neo-read-user-story and this subskill is chosen automatically when you pass it the URL or ID of an Azure DevOps work item.
When to use it
The counterpart of lippia-neo-fetch-jira-user-story for Azure DevOps: it fetches an
Azure Boards work item via the azure-devops MCP and returns it structured in memory.
It accepts a bare ID (1234), an Azure Boards URL, or a slash command argument. Unlike
the Jira one, it does a strict faithful translation — it doesn't reorder, restructure, or add
sections the work item doesn't have.
{
"input": {
"work_item_ref": "https://dev.azure.com/your-org/your-project/_workitems/edit/1234"
}
}
| Input | Type | Description |
|---|---|---|
input.work_item_ref |
Required | ID or URL of the work item; the skill extracts the canonical ID. |
input.work_item_id |
Optional | Explicit alias, if you already have the bare ID. |
input.project |
Optional | Team Project override; if not provided, it uses azure_devops.default_project from qa-stack.yaml and, failing that, AZURE_DEVOPS_DEFAULT_PROJECT from .mcp.json. |
Output
| Field | Description |
|---|---|
work_item_id |
ID of the work item, for traceability. |
content |
Full content in canonical format, in memory, ready for lippia-neo-read-user-story. |
source_url |
Canonical URL of the work item. |
title / work_item_type / state |
Title, type (User Story/Bug/Task/Feature), and state. |
ac_source |
custom_field | description | none. |
summary |
Readable summary of the operation. |
warnings |
Warnings. |
Chains with
Runs before lippia-neo-read-user-story, as its Azure DevOps "twin". It never touches the
local stories directory. The AC come from azure_devops.acceptance_criteria_field in
qa-stack.yaml (default Microsoft.VSTS.Common.AcceptanceCriteria; with null it looks for them in the
description).
lippia-neo-read-bug-report
When to use it
When starting QA work on a reported bug (not a user story). Through
a single field, it accepts three forms, detected automatically from their content: a local path to a
.md file, a ticket URL (Jira/Azure DevOps), or raw text already available (for example, injected
by the M2 dispatcher). It extracts reproduction steps, expected vs. actual result,
severity, environment, and any referenced acceptance criterion/story.
{
"input": {
"bug_report": "The 'Apply coupon' button does not show the discount when a valid coupon is confirmed in the cart."
}
}
| Input | Type | Description |
|---|---|---|
input.bug_report |
Required | Local path, remote ticket URL, or raw text of the bug; the form is detected automatically from the content. There's no dedicated key for bugs in qa-stack.yaml: a relative path is also searched under paths.user_stories_storage.local_path; if you store bugs in another folder, pass the full path. |
input.identifier |
Optional | Identifier already resolved by the caller; it takes priority over the bug_id derived from the ticket. |
input.credentials |
Optional | Test credentials already resolved by the caller; they take priority over whatever the skill finds mentioned in the report. |
Output
| Field | Description |
|---|---|
bug_id / identifier |
Short identifier of the bug, and its normalized alias. |
title |
Title of the bug. |
steps_to_reproduce / expected_result / actual_result |
Literal text from the report, never made up. |
severity |
As classified; empty if it isn't. |
environment |
URL/browser/version mentioned. |
related_user_story |
Reference to the related story/feature, or null (it isn't resolved here). |
app_urls / credentials |
URL(s) of the app and referenced test credentials. |
source_kind |
local_path | jira | azure-devops | raw_text. |
bug_report_path / source_url |
Local path or URL of the ticket, depending on source_kind. |
can_continue |
true if there was enough content to characterize the bug; null if not (never false). |
Chains with
Entry point for bugs, the counterpart of lippia-neo-read-user-story. For URLs it dispatches to
lippia-neo-fetch-jira-user-story / lippia-neo-fetch-azure-user-story. It continues with lippia-neo-find-existing-tests →
lippia-neo-bug-reproduction → lippia-neo-generate-test-suite → ....
lippia-neo-resolve-user-story-source
When to use it
When a plan or orchestrator (M2/M4) needs to decide where to read a user story reference
from — local path or remote ticket — before deciding whether to run a fetch skill. It's a
pure routing decision: it only classifies and validates a URL against the project's configuration;
it never reads a file, never touches Jira/Azure, never fetches anything. If the URL doesn't match the
provider (paths.user_stories_storage.cloud_provider_mcp) or the instance configured in
.mcp.json, it stops with the reason instead of classifying it.
{
"input": {
"user_story": "https://your-site.atlassian.net/browse/TS-42"
}
}
| Input | Type | Description |
|---|---|---|
input.user_story |
Required | Local path to a .md file or URL of a remote ticket. |
input.user_story_ref |
Optional | Explicit alias of the reference, if input.user_story isn't used. |
Output
| Field | Description |
|---|---|
kind |
local_path | jira | azure-devops: where the content needs to be fetched from. |
fetch_url_jira |
The URL as-is, only if kind == jira (it's passed to input.jira_issue_ref of the Jira fetch); null otherwise. |
fetch_url_azure_devops |
The URL as-is, only if kind == azure-devops (it's passed to input.work_item_ref of the Azure fetch); null otherwise. |
reason |
One line explaining the classification (for logs/debugging). |
Chains with
First link in the story resolution chain in M4 plans; depending on kind, it triggers
lippia-neo-fetch-jira-user-story or lippia-neo-fetch-azure-user-story, and it always continues with
lippia-neo-read-user-story → lippia-neo-create-test-plan → ....
lippia-neo-read-test-plan
When to use it
When a skill or a plan needs the information of a Markdown test plan already
structured as data, instead of parsing the .md file on its own. It reads the plan from its local
path (typically test-plans/<US-ID>-test-plan.md, generated by
lippia-neo-create-test-plan) and extracts everything:
header, scope, acceptance criteria coverage, test data, preconditions,
full scenarios with their steps, and open questions. It's read-only and literal: it doesn't
persist anything, doesn't correct or complete scenarios, and doesn't connect to external tools —
if you pass it a URL, it fails.
{
"input": {
"test_plan_path": "test-plans/LTM-21-test-plan.md"
}
}
| Input | Type | Description |
|---|---|---|
input.test_plan_path |
Required | Path (absolute or relative) to the Markdown plan; if it can't find it as given, it looks for it relative to the repo root and to paths.test_plans_dir in qa-stack.yaml (default test-plans/). Local paths only. |
Output
| Field | Description |
|---|---|
status |
read if the plan was read with at least one scenario; failed if there was no reference, it was a URL, the file doesn't exist/is empty, or it has no scenarios (the reason goes as the first warning). |
test_plan_path |
Path actually read. |
us_id / identifier |
Story identifier, taken from the file name or the plan's H1, and its normalized alias. |
header |
Plan header: title, story, app URL, credentials, stack, source of the scenarios, and other labels (extra). |
scope |
In scope / out of scope, or null if the plan doesn't include it. |
acceptance_criteria_coverage |
Coverage matrix: for each criterion (id, title), the scenarios that cover it. |
test_data / general_preconditions |
General test data (tables and notes) and general preconditions. |
scenarios |
Full scenarios: id, title, acceptance_criteria, type, priority, preconditions, steps (action + expected result per step), test_data, etc. |
open_questions |
Open questions and risks of the plan. |
other_sections / missing_sections |
Sections that don't map to any field (they're never lost) and expected sections that the plan doesn't have. |
warnings |
Detected inconsistencies (matrix vs. scenarios, steps without an expected result, possible literal credentials, etc.); they're flagged, never corrected. |
Chains with
Runs after lippia-neo-create-test-plan, on the plan that skill left on disk. Currently it's
consumed by lippia-neo-normalize-test-cases (and, through it, lippia-neo-export-test-cases).
Whoever consumes it must check status before using the result.