HAS_API = FALSE
  Set TRUE if story contains ANY of: API, endpoint, REST, GraphQL, contract,
  integration, webhook, microservice, service-to-service, HTTP, gRPC,
  request, response, payload, schema, OpenAPI, Swagger, consumer, provider

HAS_REFACTORING = FALSE
  Set TRUE if story contains ANY of: refactor, rearchitect, rewrite,
  migrate, modernize, tech debt, legacy, restructure, decouple,
  consolidate, simplify, extract, decompose, re-engineer

HAS_DEPENDENCIES = FALSE
  Set TRUE if story contains ANY of: dependency, coupling, module,
  package, library, import, shared, cross-team, upstream, downstream,
  third-party, external, vendor, SDK, plugin, middleware

HAS_SECURITY = FALSE
  Set TRUE if story contains ANY of: auth, security, credential, token,
  encrypt, PII, compliance, password, login, session, OAuth, JWT,
  permission, role, access control, RBAC, sensitive, private

HAS_MIDDLEWARE = FALSE
  Set TRUE if story contains ANY of: middleware, ESB, message broker, MQ,
  Kafka, RabbitMQ, integration bus, API gateway, message queue, pub/sub

HAS_SAP_INTEGRATION = FALSE
  Set TRUE if story contains ANY of: SAP, RFC, BAPI, IDoc, OData,
  S/4HANA, EWM, ECC, ABAP, CDS view, Fiori

HAS_AUTHORIZATION = FALSE
  Set TRUE if story contains ANY of: SoD, segregation of duties,
  role conflict, authorization object, T-code, user role,
  access control matrix, GRC

+-- I have read the entire story content
+-- I have evaluated ALL SEVEN flags
+-- I have recorded which flags are TRUE
+-- I understand which conditional agents will be needed

+-------------------------------------------------------------+
|                    FLAG DETECTION RESULTS                    |
+-------------------------------------------------------------+
|                                                             |
|  HAS_API:          [TRUE/FALSE]                             |
|  Evidence:         [what triggered it - specific patterns]  |
|                                                             |
|  HAS_REFACTORING:  [TRUE/FALSE]                             |
|  Evidence:         [what triggered it - specific patterns]  |
|                                                             |
|  HAS_DEPENDENCIES: [TRUE/FALSE]                             |
|  Evidence:         [what triggered it - specific patterns]  |
|                                                             |
|  HAS_SECURITY:     [TRUE/FALSE]                             |
|  Evidence:         [what triggered it - specific patterns]  |
|                                                             |
|  HAS_MIDDLEWARE:       [TRUE/FALSE]                         |
|  Evidence:             [what triggered it - specific]       |
|                                                             |
|  HAS_SAP_INTEGRATION: [TRUE/FALSE]                         |
|  Evidence:             [what triggered it - specific]       |
|                                                             |
|  HAS_AUTHORIZATION:   [TRUE/FALSE]                         |
|  Evidence:             [what triggered it - specific]       |
|                                                             |
|  EXPECTED AGENTS:                                           |
|  - Core: 3 (always)                                         |
|  - Conditional: [count based on TRUE flags]                 |
|  - Transformation: 1 (always)                               |
|  - TOTAL: [3 + conditional count + 1]                       |
|                                                             |
+-------------------------------------------------------------+

+-------------------------------------------------------------+
|  YOU MUST INCLUDE ALL THREE TASK CALLS IN YOUR NEXT MESSAGE  |
|                                                              |
|  - Task 1: qe-product-factors-assessor                      |
|  - Task 2: qe-bdd-generator                                 |
|  - Task 3: qe-requirements-validator                         |
|                                                              |
|  If your message contains fewer than 3 Task calls, you have |
|  FAILED this phase. Start over.                              |
+-------------------------------------------------------------+

Task({
  description: "SFDIPOT Product Factors analysis",
  prompt: `You are qe-product-factors-assessor. Your output quality is being audited.

undefined

Task({
  description: "BDD Gherkin scenario generation",
  prompt: `You are qe-bdd-generator. Your output quality is being audited.

Examples:
  | parameter | input | outcome |
  | value1    | val1  | result1 |
  | value2    | val2  | result2 |
  | value3    | val3  | result3 |

undefined

Task({
  description: "INVEST requirements validation and testability scoring",
  prompt: `You are qe-requirements-validator. Your output quality is being audited.

undefined

// Option 1: Orchestrate via Fleet
mcp__agentic-qe__fleet_init({
  topology: "hierarchical",
  enabledDomains: ["requirements-validation", "test-generation"],
  maxAgents: 7,
  lazyLoading: true
})

// Submit tasks to specific domains
mcp__agentic-qe__task_submit({
  type: "product-factors-assessment",
  priority: "p0",
  payload: {
    storyContent: storyContent,
    framework: "sfdipot",
    factorCount: 7
  }
})

mcp__agentic-qe__task_submit({
  type: "bdd-scenario-generation",
  priority: "p0",
  payload: {
    storyContent: storyContent,
    format: "gherkin",
    minScenarios: 5
  }
})

mcp__agentic-qe__task_submit({
  type: "requirements-validation",
  priority: "p0",
  payload: {
    storyContent: storyContent,
    validateInvest: true,
    assessDoR: true
  }
})

// Check task status
mcp__agentic-qe__task_list({ status: "pending" })

undefined

undefined

I've launched 3 core agents in parallel:

  qe-product-factors-assessor [Domain: requirements-validation]
   - Analyzing all 7 SFDIPOT factors (37 subcategories)
   - Assigning P0-P3 priorities per factor
   - Identifying test focus areas

  qe-bdd-generator [Domain: requirements-validation]
   - Generating Gherkin scenarios (happy, error, boundary, security)
   - Creating Scenario Outlines with Examples tables
   - Mapping scenarios to acceptance criteria

  qe-requirements-validator [Domain: requirements-validation]
   - Scoring INVEST criteria (6 dimensions)
   - Assessing AC testability with rewrites
   - Running Definition of Ready checklist

  WAITING for all agents to complete before proceeding...

+-------------------------------------------------------------+
|  YOU MUST WAIT FOR ALL THREE BACKGROUND TASKS TO COMPLETE    |
|                                                              |
|  DO NOT summarize what agents "would" find                   |
|  DO NOT proceed to Phase 4 early                             |
|  DO NOT provide your own analysis as substitute              |
|                                                              |
|  WAIT for actual agent results                               |
|  ONLY proceed when all three have returned                   |
+-------------------------------------------------------------+

From qe-product-factors-assessor:
[ ] sfdipotCoverage = __/7 factors analyzed
[ ] p0Count = __ P0 priority factors
[ ] subcategoriesAssessed = __/37 subcategories
[ ] testFocusAreas = __ areas identified

From qe-bdd-generator:
[ ] bddScenarioCount = __ scenarios generated
[ ] happyPathCount = __ happy path scenarios
[ ] errorPathCount = __ error path scenarios
[ ] boundaryCount = __ boundary scenarios
[ ] acCoverage = __% acceptance criteria covered

From qe-requirements-validator:
[ ] investCompleteness = __% (average of 6 INVEST criteria)
[ ] criticalGaps = __ critical gaps identified
[ ] dorPassRate = __/10 Definition of Ready items passing
[ ] untestableACs = __ acceptance criteria needing rewrite

+-------------------------------------------------------------+
|                    BATCH 1 RESULTS SUMMARY                   |
+-------------------------------------------------------------+
|                                                              |
|  SFDIPOT Coverage:       __/7 factors                        |
|  P0 Factors:             __                                  |
|  Subcategories Assessed: __/37                               |
|                                                              |
|  BDD Scenarios:          __ total                            |
|  - Happy Path:           __                                  |
|  - Error Path:           __                                  |
|  - Boundary:             __                                  |
|  AC Coverage:            __%                                 |
|                                                              |
|  INVEST Completeness:    __%                                 |
|  Critical Gaps:          __                                  |
|  DoR Pass Rate:          __/10                               |
|  Untestable ACs:         __                                  |
|                                                              |
+-------------------------------------------------------------+

+-------------------------------------------------------------+
|  IF A FLAG IS TRUE, YOU MUST SPAWN THAT AGENT                |
|                                                              |
|  HAS_API = TRUE              -> MUST spawn qe-contract-validator    |
|  HAS_REFACTORING = TRUE      -> MUST spawn qe-impact-analyzer      |
|  HAS_DEPENDENCIES = TRUE     -> MUST spawn qe-dependency-mapper     |
|  HAS_MIDDLEWARE = TRUE        -> MUST spawn qe-middleware-validator  |
|  HAS_SAP_INTEGRATION = TRUE  -> MUST spawn qe-odata-contract-tester|
|  HAS_AUTHORIZATION = TRUE    -> MUST spawn qe-sod-analyzer          |
|                                                              |
|  Skipping a flagged agent is a FAILURE of this skill.        |
+-------------------------------------------------------------+

IF HAS_API == FALSE AND HAS_REFACTORING == FALSE AND HAS_DEPENDENCIES == FALSE AND HAS_MIDDLEWARE == FALSE AND HAS_SAP_INTEGRATION == FALSE AND HAS_AUTHORIZATION == FALSE:
    -> Skip to Phase 5 (no conditional agents needed)
    -> State: "No conditional agents needed based on story analysis"

ELSE:
    -> Spawn ALL applicable agents in ONE message
    -> Count how many you're spawning: __

Task({
  description: "Consumer-driven contract validation",
  prompt: `You are qe-contract-validator. Your output quality is being audited.

undefined

Task({
  description: "Refactoring blast radius and impact analysis",
  prompt: `You are qe-impact-analyzer. Your output quality is being audited.

[Changed Component]
  +-- [Direct Dependent 1]
  |     +-- [Transitive Dependent 1a]
  |     +-- [Transitive Dependent 1b]
  +-- [Direct Dependent 2]
        +-- [Transitive Dependent 2a]

undefined

Task({
  description: "Dependency coupling analysis and circular detection",
  prompt: `You are qe-dependency-mapper. Your output quality is being audited.

undefined

Task({
  description: "Middleware routing, transformation, and ESB flow validation",
  prompt: `You are qe-middleware-validator. Your output quality is being audited.

undefined

Task({
  description: "OData contract and SAP service validation",
  prompt: `You are qe-odata-contract-tester. Your output quality is being audited.

undefined

Task({
  description: "Segregation of duties and authorization conflict analysis",
  prompt: `You are qe-sod-analyzer. Your output quality is being audited.

undefined

// IF HAS_API - Enable contract-testing domain
if (HAS_API) {
  mcp__agentic-qe__task_submit({
    type: "contract-validation",
    priority: "p0",
    payload: {
      storyContent: storyContent,
      framework: "consumer-driven",
      detectBreaking: true
    }
  })
}

// IF HAS_REFACTORING - Enable code-intelligence domain
if (HAS_REFACTORING) {
  mcp__agentic-qe__coverage_analyze_sublinear({
    target: "src/",
    detectGaps: true,
    blastRadius: true
  })
}

// IF HAS_DEPENDENCIES - Enable code-intelligence domain
if (HAS_DEPENDENCIES) {
  mcp__agentic-qe__defect_predict({
    target: "src/",
    analyzeCoupling: true,
    detectCircular: true
  })
}

// IF HAS_MIDDLEWARE - Enable enterprise-integration domain
if (HAS_MIDDLEWARE) {
  mcp__agentic_qe__task_orchestrate({
    task: "middleware-routing-validation",
    strategy: "parallel",
    payload: {
      storyContent: storyContent,
      validateRouting: true,
      validateTransforms: true
    }
  })
}

// IF HAS_SAP_INTEGRATION - Enable enterprise-integration domain
if (HAS_SAP_INTEGRATION) {
  mcp__agentic_qe__task_orchestrate({
    task: "odata-contract-validation",
    strategy: "parallel",
    payload: {
      storyContent: storyContent,
      validateMetadata: true,
      validateSchema: true
    }
  })
}

// IF HAS_AUTHORIZATION - Enable enterprise-integration domain
if (HAS_AUTHORIZATION) {
  mcp__agentic_qe__task_orchestrate({
    task: "sod-authorization-analysis",
    strategy: "parallel",
    payload: {
      storyContent: storyContent,
      detectSoD: true,
      detectToxicCombos: true
    }
  })
}

undefined

undefined

+-------------------------------------------------------------+
|                   AGENT COUNT VALIDATION                     |
+-------------------------------------------------------------+
|                                                              |
|  CORE AGENTS (ALWAYS 3):                                     |
|    [ ] qe-product-factors-assessor - SPAWNED? [Y/N]         |
|    [ ] qe-bdd-generator - SPAWNED? [Y/N]                    |
|    [ ] qe-requirements-validator - SPAWNED? [Y/N]            |
|                                                              |
|  CONDITIONAL AGENTS (based on flags):                        |
|    [ ] qe-contract-validator - SPAWNED? [Y/N] (HAS_API)     |
|    [ ] qe-impact-analyzer - SPAWNED? [Y/N] (HAS_REFACTORING)|
|    [ ] qe-dependency-mapper - SPAWNED? [Y/N] (HAS_DEPS)     |
|    [ ] qe-middleware-validator - SPAWNED? [Y/N] (HAS_MIDDLEWARE)    |
|    [ ] qe-odata-contract-tester - SPAWNED? [Y/N] (HAS_SAP_INTEG)  |
|    [ ] qe-sod-analyzer - SPAWNED? [Y/N] (HAS_AUTHORIZATION)       |
|                                                              |
|  VALIDATION:                                                 |
|    Expected agents: [3 + count of TRUE flags]                |
|    Actual spawned:  [count]                                  |
|    Status:          [PASS/FAIL]                              |
|                                                              |
|  If ACTUAL < EXPECTED, you have FAILED. Spawn missing        |
|  agents before proceeding.                                   |
|                                                              |
+-------------------------------------------------------------+

I've launched [N] conditional agent(s) in parallel:

[IF HAS_API]             qe-contract-validator [Domain: contract-testing]
                         - Consumer-driven contracts, breaking changes
[IF HAS_REFACTORING]     qe-impact-analyzer [Domain: code-intelligence]
                         - Blast radius, affected tests, regression risk
[IF HAS_DEPENDENCIES]    qe-dependency-mapper [Domain: code-intelligence]
                         - Coupling metrics Ca/Ce/I, circular detection
[IF HAS_MIDDLEWARE]      qe-middleware-validator [Domain: enterprise-integration]
                         - Middleware routing, transformation, ESB flow validation
[IF HAS_SAP_INTEGRATION] qe-odata-contract-tester [Domain: enterprise-integration]
                         - OData contract, SAP service, $metadata validation
[IF HAS_AUTHORIZATION]   qe-sod-analyzer [Domain: enterprise-integration]
                         - Segregation of duties, role conflict, authorization analysis

  WAITING for conditional agents to complete...

STEP 1: Check NOT-READY conditions (ANY triggers NOT-READY)
-----------------------------------------------------------
IF sfdipotCoverage < 5          -> NOT-READY ("Insufficient factor coverage")
IF bddScenarioCount < 3         -> NOT-READY ("Too few BDD scenarios")
IF investCompleteness < 50       -> NOT-READY ("Requirements incomplete")
IF criticalGaps > 3              -> NOT-READY ("Too many critical gaps")

STEP 2: Check READY conditions (ALL required for READY)
-----------------------------------------------------------
IF sfdipotCoverage >= 7
   AND bddScenarioCount >= 10
   AND investCompleteness >= 90
   AND criticalGaps == 0         -> READY

STEP 3: Default
-----------------------------------------------------------
ELSE                             -> CONDITIONAL

METRICS:
- sfdipotCoverage = __/7
- bddScenarioCount = __
- investCompleteness = __%
- criticalGaps = __

NOT-READY CHECK:
- sfdipotCoverage < 5? __ (YES/NO)
- bddScenarioCount < 3? __ (YES/NO)
- investCompleteness < 50? __ (YES/NO)
- criticalGaps > 3? __ (YES/NO)

READY CHECK (only if no NOT-READY triggered):
- sfdipotCoverage >= 7? __ (YES/NO)
- bddScenarioCount >= 10? __ (YES/NO)
- investCompleteness >= 90? __ (YES/NO)
- criticalGaps == 0? __ (YES/NO)

FINAL RECOMMENDATION: [READY / CONDITIONAL / NOT-READY]
REASON: ___

undefined

Write the executive summary report to:
`${OUTPUT_FOLDER}/01-executive-summary.md`

+-- Executive Summary table is complete with all 4 metrics
+-- Recommendation matches decision logic output
+-- SFDIPOT section includes all 7 factor priorities
+-- BDD section includes scenario coverage summary
+-- INVEST score shows all 6 criteria
+-- All gaps are listed
+-- Conditional sections included for all spawned agents
+-- Recommended actions are specific (not generic)
+-- Report saved to output folder

+-------------------------------------------------------------+
|  LEARNING PERSISTENCE MUST ALWAYS EXECUTE                    |
|                                                              |
|  This is NOT optional. It runs on EVERY refinement.          |
|  It stores findings for cross-phase feedback loops,          |
|  historical decision analysis, and pattern learning.         |
|                                                              |
|  DO NOT skip this phase for any reason.                      |
|  DO NOT treat this as "nice to have".                        |
|  Enforcement Rule E9 applies.                                |
+-------------------------------------------------------------+

mcp__agentic-qe__memory_store({
  key: `qcsd-refinement-${storyId}-${Date.now()}`,
  namespace: "qcsd-refinement",
  value: {
    storyId: storyId,
    storyName: storyName,
    recommendation: recommendation,  // READY, CONDITIONAL, NOT-READY
    metrics: {
      sfdipotCoverage: sfdipotCoverage,
      bddScenarioCount: bddScenarioCount,
      investCompleteness: investCompleteness,
      criticalGaps: criticalGaps
    },
    sfdipotPriorities: {
      structure: "P0/P1/P2/P3",
      function: "P0/P1/P2/P3",
      data: "P0/P1/P2/P3",
      interfaces: "P0/P1/P2/P3",
      platform: "P0/P1/P2/P3",
      operations: "P0/P1/P2/P3",
      time: "P0/P1/P2/P3"
    },
    flags: {
      HAS_API: HAS_API,
      HAS_REFACTORING: HAS_REFACTORING,
      HAS_DEPENDENCIES: HAS_DEPENDENCIES,
      HAS_SECURITY: HAS_SECURITY,
      HAS_MIDDLEWARE: HAS_MIDDLEWARE,
      HAS_SAP_INTEGRATION: HAS_SAP_INTEGRATION,
      HAS_AUTHORIZATION: HAS_AUTHORIZATION
    },
    agentsInvoked: agentList,
    timestamp: new Date().toISOString()
  }
})

mcp__agentic-qe__memory_share({
  sourceAgentId: "qcsd-refinement-swarm",
  targetAgentIds: ["qe-learning-coordinator", "qe-pattern-learner"],
  knowledgeDomain: "refinement-patterns"
})

Save to: ${OUTPUT_FOLDER}/09-learning-persistence.json

Contents:
{
  "phase": "QCSD-Refinement",
  "storyId": "[story ID]",
  "storyName": "[story name]",
  "recommendation": "[READY/CONDITIONAL/NOT-READY]",
  "memoryKey": "qcsd-refinement-[storyId]-[timestamp]",
  "namespace": "qcsd-refinement",
  "metrics": {
    "sfdipotCoverage": [0-7],
    "bddScenarioCount": [N],
    "investCompleteness": [0-100],
    "criticalGaps": [N],
    "testIdeaQuality": [0-100]
  },
  "sfdipotPriorities": {
    "structure": "P0/P1/P2/P3",
    "function": "P0/P1/P2/P3",
    "data": "P0/P1/P2/P3",
    "interfaces": "P0/P1/P2/P3",
    "platform": "P0/P1/P2/P3",
    "operations": "P0/P1/P2/P3",
    "time": "P0/P1/P2/P3"
  },
  "flags": {
    "HAS_API": true/false,
    "HAS_REFACTORING": true/false,
    "HAS_DEPENDENCIES": true/false,
    "HAS_SECURITY": true/false,
    "HAS_MIDDLEWARE": true/false,
    "HAS_SAP_INTEGRATION": true/false,
    "HAS_AUTHORIZATION": true/false
  },
  "agentsInvoked": ["list", "of", "agents"],
  "crossPhaseSignals": {
    "toDevelopment": "BDD scenarios as test specification",
    "toVerification": "INVEST gaps as verification focus"
  },
  "persistedAt": "[ISO timestamp]"
}

npx @claude-flow/cli@latest memory store \
  --key "qcsd-refinement-${STORY_ID}-$(date +%s)" \
  --value '{"recommendation":"[VALUE]","investCompleteness":[N],"sfdipotCoverage":[N],"bddScenarioCount":[N],"criticalGaps":[N]}' \
  --namespace qcsd-refinement

npx @claude-flow/cli@latest hooks post-task \
  --task-id "qcsd-refinement-${STORY_ID}" \
  --success true

+-- Did I execute mcp__agentic-qe__memory_store with actual values? (not placeholders)
+-- Did I execute mcp__agentic-qe__memory_share to propagate learnings?
+-- Did I save 09-learning-persistence.json to the output folder?
+-- Does the JSON contain the correct recommendation from Phase 5?
+-- Does the JSON contain actual SFDIPOT priorities from Phase 2?
+-- Does the JSON contain actual flag values from Phase 1?

CONSUMES (from other phases):
+-- Loop 2 (Tactical): SFDIPOT weights from Production Telemetry
|   - Production incidents inform which factors to weight higher
|   - Telemetry data adjusts P0-P3 priority thresholds
|
+-- Loop 4 (Quality-Criteria): Untestable patterns from Development
    - Patterns the Development phase flagged as hard to test
    - Feeds into INVEST testability scoring

PRODUCES (for other phases):
+-- To Development Phase: BDD scenarios as test specification
|   - Gherkin scenarios become automated test templates
|   - SFDIPOT priorities guide test depth allocation
|
+-- To Verification Phase: INVEST gaps as verification focus
    - Critical gaps become verification checkpoints
    - DoR failures become sprint exit criteria

+-------------------------------------------------------------+
|  THE TEST IDEA REWRITER MUST ALWAYS RUN                      |
|                                                              |
|  This is NOT conditional. It runs on EVERY refinement.       |
|  It transforms passive test ideas into active, actionable    |
|  test specifications using strong action verbs.              |
|                                                              |
|  DO NOT skip this phase for any reason.                      |
+-------------------------------------------------------------+

Task({
  description: "Transform test ideas with action verbs",
  prompt: `You are qe-test-idea-rewriter. Your output quality is being audited.