==================================================
 STORYGEN AI — STORY EXPORT
==================================================
Story ID:           24
Title:              CLaaS developer version 1 (Autonomous)
Owner:              Noel Anthony - Product Manager <noel.anthony@educlaas.com>
App Type:           Agentic AI App
Input Type:         file
Status:             features_generated
Source File:        End_to_End_Process_Feature_lists_CLaaS_Developer.pdf
Created:            2026-04-29 07:45:23 UTC
Updated:            2026-04-29 07:47:41 UTC
Features Generated: 2026-04-29 07:47:41 UTC
Total Clusters:     7
Total Features:     18

--- ORIGINAL INPUT ---
End-to-End Process Feature Lists – CLaaS Developer 
Converted from Excel workbook: End_to_End_Process_Feature_lists_CLaaS Developer.xlsx | Sheet: Developer 
 
Module Feature Cluster 	Feature 	Description 	Workflow 
CLaaS Developer Product Catalogue 	Master list of the modules-- Session Plan 
details 
Session Plan Details 	1. View list of Modules & Sessions 
2. Session Plan review (internal & External) 
3. Internal view per module (with links per IU) 
4. External view (with links) 
CLaaS Developer ClaaS Master Course Information 
(Product Catalogue) 
Master list of the modules-- --Product code & 
name-- Course Code & Name -- Product Plan 
Course Details (Fetched via API from the Product 
Apps) 
1. Product Name 
2. Product Code 
3. Course Code 
4. Course Name 
5. Product Plan 
6. Module Details 
CLaaS Developer ClaaS Seestion Plan copy Copy Sessin plan, KSA, IU's -> new module Copy an existing session plan with all contents 
(Links, generated files, Autograder Scrip, etc) to a 
new product  
1. Select session plan module to copy 
2. Select the module to copy over 
3. Select confirm 
 
CLaaS Developer CLaaS Product Admin Course & Product Creation – Product Product record (manual create course & product 
capability) 
- Funtion is an option if product not available in 
the products apps(fetched via API) 
1. Create a record for each module 
2. Connect the module to its parent course 
3. Set the module code, title, and how long it takes to 
complete 
4. Add the LMS course code and the link to the LMS course 
page 
5. Connect the module to its Technical Skills and 
Competency (TSC) entry 
6. Turn on sync if needed and set the order in which modules 
appear 
CLaaS Developer CLaaS Course Admin Course & Product Creation – Courses Course record 	1. Create a record for each course 
2. Set both the internal and public-facing course names 
3. Add the course code and specify the course type 
4. Turn on the sync setting if the course needs to stay 
updated automatically 
5. Set the order in which courses appear 
CLaaS Developer CLaaS Product Admin Course & Product Document Automation – 
Course-Product Mapping 
Course-module mapping 	1. Link each module to its parent course 
2. Set the course and module references for each mapping 
3. Assign a unique identifier to each course-module link 
CLaaS Developer CLaaS Proficiency Admin Product Planning & Structure – Proficiency 
Goals 
Proficiency goal config 	1. Add the proficiency goals (e.g Basic & Advance) 
2. Give each goal a name and short reference name 
3. Set the order in which they appear 
CLaaS Developer CLaaS KSA Admin 	KSA & Proficiency Mapping – Proficiency 
Groupings 
Proficiency grouping 	1. Create proficiency grouping entries 
2. Connect each grouping to its competency level 
3. Connect each grouping to its proficiency goal 
4. Assign the matching learning management system (LMS) 
group 
5. Set the order in which they appear 
CLaaS Developer CLaaS Instructional Unit Admin Instructional Unit (IU) Management – Session 
Modes 
Session mode config 	1. Add the session delivery modes (e.g. Synchronous, 
Asynchronous) 
2. Add the sub-types under each session mode 
3. Give each mode and sub-type a name and set the order in 
which they appear 
CLaaS Developer CLaaS Instructional Unit Admin Instructional Unit (IU) Management – Asset 
Format Types 
Asset format type config 	1. Add the asset format types (e.g, PDF) 
2. Give each format a name and short reference name 
3. Set the order in which they appear

Module Feature Cluster 	Feature 	Description 	Workflow 
CLaaS Developer CLaaS Grading Criteria Admin Product Planning & Structure – Competency 
Levels--Confiquration of generated from 
rubrics to Actionable prompt for Autograder  
Competency level config 	1. Add the competency levels (e.g. Basic =>Fail(49% & 
below),Foundation(50-74%), Proficient(75% & Above) & 
Advance =>Fail(49% & below),Foundation(50-59%), 
Proficient(60% & 79%), Expert(80% & above)) 
2. Give each level a short reference name 
3. Set the order in which they appear 
4. Assign a unique identifier to each level 
CLaaS Developer CLaaS Content Grouping Admin Product Planning & Structure – Content 
Grouping--Prompt 
Content group config 	1. Add the content categories and problem types 
2. Give each category a name and short reference name 
3. Set the order in which they appear 
4. Assign a unique identifier to each category 
CLaaS Developer CLaaS Content Type Admin AI Content & Assessment Generation – 
Session Mode Content Types-- Prompts 
Content type config 	1. Add the content types available for each session mode 
2. Add the prompts used to generate content with AI 
3. Add the prompts used to evaluate and score the content 
4. Add the prompt used to configure automatic grading 
5. Connect each content type to its format type and content 
category 
6. Indicate whether this content type can be AI-generated 
CLaaS Developer CLaaS Assessment type Admin Assessment Automation – Assessment 
Types-- Prompts 
Assessment type config 	1. Add the assessment types 
2. Connect each assessment type to its content category 
3. Link each assessment to its problem type 
4. Associate each assessment with its session mode and 
session mode sub-type 
5. Set the order in which they appear 
CLaaS Developer CLaaS TSC Admin 	Product Planning & Structure – Technical 
Skills & Competencies (TSC) 
TSC config 	1. Add the Technical Skills and Competency (TSC) codes and 
titles 
2. Set the TSC categories and descriptions 
3. Fill in the related knowledge and skills details 
4. Set the order in which they appear 
5. Assign a unique identifier to each TSC entry 
CLaaS Developer CLaaS Product Admin Foundation Setup – Languages & 
Technologies 
Reference data config 	1. Add the languages that the platform will support 
2. Add the technologies that will be used 
3. Give each entry a name and set the order in which they 
appear 
CLaaS Developer CLaaS Product Admin User Administration – User Setup--RBA User record 	1. Create a record for each user 
2. Enter the user's name and email address 
3. A unique user ID is generated automatically 
4. Connect the user to the relevant modules and assign their 
role 
CLaaS Developer CLaaS Product Development KSA & Proficiency Mapping – Module 
Knowledge 
Module knowledge 	1. Add the knowledge items that belong to each module 
2. Give each knowledge item a clear, descriptive name 
3. Connect it to its module 
4. Set the order in which knowledge items appear 
CLaaS Developer CLaaS Product Development KSA & Proficiency Mapping – Module Skills Module skill 	1. Add the skill items that belong to each module 
2. Give each skill item a clear, descriptive name 
3. Connect it to its module 
4. Set the order in which skill items appear 
CLaaS Developer CLaaS Product Development KSA & Proficiency Mapping – Module Abilities Module ability 	1. Add the ability items that belong to each module 
2. Give each ability item a clear, descriptive name 
3. Connect it to its module 
4. Set the order in which ability items appear 
5. Assign a unique identifier to each ability item 
CLaaS Developer CLaaS Product Development Instructional Unit (IU) Management – Create 
IUs 
Instructional unit 	1. Create an Instructional Unit (IU) record for each module 
2. Give the IU a name and set the order in which it appears 
3. Connect it to its parent module 
4. Assign a unique IU identifier 
CLaaS Developer CLaaS Product Development KSA & Proficiency Mapping – IU Knowledge 
Items 
IU knowledge mapping 	1. Assign the relevant knowledge items to each Instructional 
Unit (IU) 
2. Connect each knowledge item to its source in the module

Module Feature Cluster 	Feature 	Description 	Workflow 
knowledge list 
3. Connect it to its Instructional Unit 
4. Set the order in which knowledge items appear within the 
IU 
CLaaS Developer CLaaS Product Development KSA & Proficiency Mapping – IU Skill Items IU skill mapping 	1. Assign the relevant skill items to each Instructional Unit 
(IU) 
2. Connect each skill item to its source in the module skills 
list 
3. Connect it to its Instructional Unit 
4. Set the order in which skill items appear within the IU 
CLaaS Developer CLaaS Product Development KSA & Proficiency Mapping – IU Ability Items IU ability mapping 	1. Assign the relevant ability items to each Instructional Unit 
(IU) 
2. Connect each ability item to its source in the module 
abilities list 
3. Connect it to its Instructional Unit 
4. Set the order in which ability items appear within the IU 
CLaaS Developer CLaaS Product Development Instructional Unit (IU) Management – Session 
Plans 
Session plan 	1. Create a session plan record for each Instructional Unit 
(IU) 
2. Connect the session plan to its Instructional Unit 
3. Set the session delivery mode, sub-type, and content type 
4. Set the session duration (in minutes) and its reference 
number 
5. Add the link to the content repository 
6. Set the order in which session plans appear 
CLaaS Developer CLaaS Product Development KSA & Proficiency Mapping – Session Plan to 
PC Groupings 
Session-PC grouping mapping 	1. Connect each session plan to its proficiency and 
competency grouping 
2. Link the session plan to the session plans list 
3. Link it to the proficiency and competency groupings list 
CLaaS Developer CLaaS Product Development Instructional Unit (IU) Management – Content 
Mapping 
Content mapping 	1. Link each content item to its Instructional Unit and module 
2. Connect it to its proficiency and competency grouping 
3. Set the session delivery mode, sub-type, content type, and 
file format 
4. Assign the relevant technologies 
5. Set the order in which it appears within the IU and within 
the module 
CLaaS Developer ClaaS Session Plan Entry Session Plan Entry 	Session Plan Confiq 	1. Session Plan groups 
2. Instructional Unit 
3. Session Mode 
4. Category 
5. Content Type 
6. Topic 
7. Session Day and Week 
8. Duration of content 
CLaaS Developer CLaaS Product Development AI Content & Assessment Generation – 
Content Repository 
Content repository & Content generation 1. Create a content record for each Instructional Unit and 
module 
2. Connect it to its Instructional Unit and module 
3. Set the session delivery mode, sub-type, and content type 
4. Add the SharePoint file details (file ID, link, name, and tags) 
5. Enter the prompt used to generate this content with AI 
6. Set how the file was created and the order in which it 
appears 
CLaaS Developer CLaaS Product Development Assessment Automation – Content Rubrics Content rubric generation 	1. Create a rubric record and link it to the relevant content 
item 
2. Connect it to its Instructional Unit, module, and course 
3. Add the prompt used to evaluate and score this content 
4. Add the SharePoint file details for the rubric (file ID, link, 
name, and tags) 
5. Connect it to its session delivery mode and sub-type 
CLaaS Developer CLaaS Product Development Assessment Automation – Autograding Autograding config & generation 	1. Create an autograding setup record for each content item

Module Feature Cluster 	Feature 	Description 	Workflow 
Configuration 	2. Link it to the relevant content item and its rubric 
3. Connect it to the module, course, and session records 
4. Add the grading script 
5. Add the SharePoint file details for the grading file 
6. Connect it to its Instructional Unit 
CLaaS Developer AutoGrader Engine 	grading--configurations–assignments grade_conf_id 
order_index 
session_id 
session_plan_id 
course_code 
course_name 
module_name 
instructional_unit 
session_mode 
category 
content_topic 
prompt_file_name 
prompt_file_mime 
prompt_file_size 
prompt_file_data 
created_at 
updated_at 
1. Set a unique ID for each grading configuration 
2. A sequence number is assigned automatically 
3. Add the external session reference ID 
4. Link the configuration to a specific session plan 
5. Enter the course code (e.g. PCDI1) 
6. Enter the full course title 
7. Enter the module name 
8. Enter the specific lesson unit 
CLaaS Developer Autograder Submission grading–submissions–score–email grade_sub_id 
grade_conf_id 
learner_email 
cohort_code 
learner_file_data 
prompt_file_data 
openai_response 
is_openai_response_valid 
is_email_sent 
is_grading_completed 
process_attempt_count 
process_attempt_logs 
created_at 
1. Set a unique ID for each submission 
2. Link the submission to its grading configuration 
3. Enter the learner's email address 
4. Enter the cohort code that the learner belongs to 
5. Attach the learner's submitted file 
CLaaS Developer Product Analytics / PowerBI Dashboard KPI – Total Users 	Count of total registered users 	1. Pull the list of all registered users 
2. Count the total number of users 
3. Show the count as a summary number on the dashboard 
CLaaS Developer Product Analytics / PowerBI Dashboard KPI – Active Sessions Count of active module session plans 1. Pull the list of all module session plans 
2. Count the total number of active sessions 
3. Show the count as a summary number on the dashboard 
CLaaS Developer Product Analytics / PowerBI Dashboard KPI – Modules Created Count of product app modules created 1. Pull the list of all product modules 
2. Count the total number of modules created 
3. Show the count as a summary number on the dashboard 
CLaaS Developer Product Analytics / PowerBI Dashboard Chart – Content Volume Content repository volume by creation method 
and date 
1. Pull the content repository records 
2. Group content by the date it was created 
3. Break down each group by how the content was made (e.g. 
uploaded, AI-generated) 
4. Show the results as a chart on the dashboard 
CLaaS Developer Product Analytics / PowerBI Dashboard Chart – User Distribution User role distribution: Admin, User, Technology 1. Pull the list of all users 
2. Categorise each user as Admin, User, or Technology based 
on their name/role 
3. Show the breakdown as a distribution chart on the 
dashboard 
CLaaS Developer Product Analytics / PowerBI Dashboard Table – Recent Activity Recent activity across modules, sessions, and 
content (5 rows) 
1. Count the total number of modules created 
2. Count the total number of active sessions 
3. Count content items that were manually uploaded via link 
4. Count content items that were AI-generated 
5. Count content items uploaded via SharePoint link

Module Feature Cluster 	Feature 	Description 	Workflow 
6. Display all five counts as a recent activity summary table 
on the dashboard 
CLaaS Developer Product Analytics / PowerBI Learner Feedback - fetched from ClaaS 
Manager 
A report focusing on learners Feedback on 
product. 
Load embedded Power BI report → fetch learner analytics 
(Learner feedback.) → render interactive dashboard inside 
iframe → allow users to view and analyze learner feedback 
metrics 
CLaaS Developer Curricumlum Framework 
Alignment 
Curriculum Framework Alignment & Gap 
Analysis 
Framework Confiquration 	1.Confiqure the country 
2. Load the Product Plan 
3. Load the skillsframework 
4. Perform Alignment Check 
5. Higliglight alignment & Gap 
6. Recommendations to fill the idenfied gaps 
     
     
Under Development 
Future Enhancements 
Integration with LMS 
 
Note: Multi-line Excel cell content has been preserved as line breaks in the Word table.

--- USER STORY ---
# CLaaS Developer: Agentic AI-Powered Curriculum & Content Authoring Platform

## Overview
This is an **Agentic AI App** that empowers curriculum developers to design, structure, and produce learning products (courses, modules, instructional units, session plans, content, rubrics, and autograders) with the help of autonomous AI agents. While developers retain control over product taxonomy and approvals, AI agents handle content generation, rubric drafting, autograder script creation, learner submission grading, and curriculum-framework gap analysis — dramatically reducing manual authoring effort while preserving pedagogical quality.

## Actors
- **Curriculum Developer (Primary Human User)**: Defines courses, modules, IUs, KSAs, proficiency goals, session plans, and approves AI-generated artifacts.
- **Product Admin**: Maintains master reference data (languages, technologies, users, RBAC, course-product mappings).
- **Instructional Designer**: Configures session modes, asset format types, content groupings, competency levels, and assessment types (including prompts).
- **Learner (External)**: Submits assignment files for autograding (indirect actor).
- **Content Generation Agent**: Autonomously generates instructional content (PDFs, slides, exercises) using configured prompts, session mode, content type, and KSA mappings; writes outputs to the SharePoint content repository.
- **Rubric Authoring Agent**: Generates evaluation rubrics for each content item using rubric prompts; links rubrics to content, IU, module, and course.
- **Autograder Configuration Agent**: Translates rubrics into actionable grading prompts and grading scripts; stores grading config with file artifacts.
- **AutoGrader Engine Agent**: Receives learner submissions, calls the LLM with the grading prompt + learner file, validates the response, computes scores, persists results, and triggers learner feedback emails.
- **Curriculum Alignment Agent**: Compares the Product Plan against a country-specific Skills Framework, highlights alignment and gaps, and recommends remediations.
- **Analytics Agent**: Aggregates platform telemetry into KPIs, charts, and recent-activity tables surfaced via embedded Power BI.

## Goals
- Accelerate end-to-end curriculum authoring (from product catalogue through autograding) using AI agents.
- Maintain a single source of truth for course/product/module/IU/KSA structures, fetched via API from the Product Apps where available.
- Automate content, rubric, and autograder generation while keeping developers in the approval loop.
- Provide consistent, prompt-driven autograding of learner submissions with auditable results.
- Surface real-time product KPIs and learner-feedback analytics to developers.
- Identify curriculum gaps against national skills frameworks and recommend fixes.

## User Story
As a **Curriculum Developer**, I want **AI agents to generate, evaluate, and grade learning content based on the session plans, KSAs, rubrics, and prompts I configure**, so that I can **publish high-quality, framework-aligned learning products faster while focusing my time on pedagogical decisions rather than manual content production**.

## Detailed Workflow

### 1. Foundation & Master Data Setup (Human-driven)
1. Product Admin creates/syncs **Courses** and **Modules** — either fetched via API from the Product Apps (Product Name, Product Code, Course Code/Name, Product Plan, Module Details) or created manually if unavailable.
2. Admin maintains **Course-Module mappings**, **Languages & Technologies**, and **User records** (with auto-generated user IDs and RBAC role assignments).
3. Instructional Designer configures reference taxonomies: **Proficiency Goals** (Basic, Advanced), **Proficiency Groupings**, **Session Modes** (Synchronous/Asynchronous + sub-types), **Asset Format Types** (e.g., PDF), **Competency Levels** (with grade bands such as Basic: Fail ≤49%, Foundation 50–74%, Proficient ≥75%; Advanced: Fail ≤49%, Foundation 50–59%, Proficient 60–79%, Expert ≥80%), **Content Groupings**, **Content Types** (with generation/evaluation/autograding prompts), and **Assessment Types**.
4. Developer adds **TSC (Technical Skills & Competencies)** entries with codes, titles, categories, and related knowledge/skills.

### 2. Product Structure & KSA Mapping (Human-driven)
5. Developer creates **Module Knowledge / Skill / Ability** items per module.
6. Developer creates **Instructional Units (IUs)** under each module and maps the relevant **Knowledge, Skill, and Ability** items into each IU.
7. Developer creates **Session Plans** per IU, specifying session mode, sub-type, content type, duration, and content repository link; maps each session plan to its **Proficiency-Competency Grouping**.
8. Optionally, developer uses **Session Plan Copy** to clone an existing session plan (with all links, generated files, autograder scripts) into a new module.

### 3. AI Content Generation (Agent-driven)
9. Developer triggers content generation for a session plan/IU. The **Content Generation Agent**:
   - Reads the configured **content type prompt**, session mode, KSAs assigned to the IU, technologies, and proficiency grouping.
   - Calls the LLM to draft content matching the asset format type (e.g., PDF).
   - Writes the artifact to SharePoint and creates a content record (file ID, link, name, tags, generation method, order index).
   - Flags the record as "AI-generated, pending review."
10. Developer reviews and approves (or edits/regenerates) the content before it becomes active.

### 4. Rubric & Autograder Authoring (Agent-driven)
11. For each approved content item, the **Rubric Authoring Agent** uses the configured **evaluation prompt** to draft a rubric mapped to the relevant competency level bands; saves rubric to SharePoint and links it to content/IU/module/course.
12. The **Autograder Configuration Agent** converts the rubric into an **actionable grading prompt** plus a grading script; persists a grading configuration record (`grade_conf_id`, `session_plan_id`, course/module/IU references, prompt file metadata).
13. Developer reviews, edits if needed, and approves the rubric and autograder configuration.

### 5. Learner Submission & Autograding (Agent-driven, runtime)
14. Learner submission arrives with `learner_email`, `cohort_code`, and submitted file. The **AutoGrader Engine Agent**:
   - Creates a `grade_sub_id` linked to the relevant `grade_conf_id`.
   - Sends the prompt + learner file to the LLM.
   - Validates the LLM response (`is_openai_response_valid`); on invalid response, retries up to a configured `process_attempt_count` and logs each attempt.
   - On success, computes the score band per the competency-level configuration, marks `is_grading_completed`, and dispatches the feedback email (`is_email_sent`).
   - On repeated failure, escalates to a human grader.

### 6. Curriculum Framework Alignment (Agent-driven)
15. Developer selects a country and loads the Product Plan. The **Curriculum Alignment Agent**:
   - Loads the country's skills framework.
   - Performs an alignment check between the Product Plan and the framework.
   - Highlights aligned items and gaps.
   - Generates recommendations to close identified gaps.
16. Developer reviews recommendations and accepts/iterates them into the product structure.

### 7. Analytics & Dashboards (Agent-driven, continuous)
17. The **Analytics Agent** continuously refreshes Power BI dashboards: KPIs (Total Users, Active Sessions, Modules Created), Content Volume chart (by creation method and date), User Distribution chart (Admin/User/Technology), Recent Activity table, and an embedded **Learner Feedback** report fetched from CLaaS Manager.

## Acceptance Criteria

### Functional
- Developer can view internal (per-module, per-IU links) and external session plan reviews.
- Master data (courses, modules, IUs, KSAs, proficiency goals/groupings, session modes, content types, assessment types, TSCs, competency levels) can be created, ordered, and uniquely identified.
- Course/Product data fetched via API from the Product Apps overrides manual entry when available; manual creation is enabled only when API data is missing.
- Session Plan Copy duplicates session plan, KSAs, IUs, links, generated files, and autograder scripts to a target module.
- Content, rubrics, and autograder configurations are persisted with SharePoint file IDs, links, names, tags, and order indexes.
- Autograder records capture all required fields (`grade_conf_id`, `grade_sub_id`, `learner_email`, `cohort_code`, prompt/learner file data, OpenAI response, validity flag, email-sent flag, completion flag, attempt count, attempt logs, timestamps).
- Power BI dashboards render KPIs, charts, recent activity, and learner feedback inside an iframe.
- Curriculum Alignment produces a visual alignment-vs-gap output plus written recommendations.

### Agent Guardrails & Escalation
- **Human-in-the-loop**: All AI-generated content, rubrics, and autograder configurations are marked "Pending Review" and require explicit developer approval before becoming active.
- **Prompt fidelity**: Agents must use the configured content-type/evaluation/grading prompts; any deviation must be logged.
- **Validation**: AutoGrader Engine must validate every LLM response (`is_openai_response_valid`); invalid responses trigger retry up to the configured maximum.
- **Escalation**: After max retries, the AutoGrader Engine flags the submission for human review and notifies the developer; no automatic email goes to the learner.
- **Stop conditions**: Agents must halt and request human input when (a) required KSA/competency mappings are missing, (b) referenced SharePoint paths are inaccessible, (c) the LLM returns content flagged as unsafe or off-topic, or (d) the Curriculum Alignment Agent cannot locate the specified country framework.
- **Auditability**: Every agent action (generation, scoring, retry, escalation) is logged with timestamp, agent identity, prompt used, and outcome.
- **RBAC enforcement**: Agents respect the user's role permissions when reading/writing records.

## Assumptions & Constraints
- The Product Apps expose a stable API for course/product/module data; manual creation is a fallback only.
- SharePoint is the canonical content repository; all generated artifacts must be writable there with file metadata captured.
- An LLM provider (e.g., OpenAI) is available, and prompts are version-controlled within content type, assessment type, and grading configurations.
- Competency-level grade bands and proficiency goals are configurable per product (Basic vs. Advanced schemes shown as examples).
- LMS integration is listed as a **Future Enhancement** and is out of scope for this story.
- Power BI reports for learner feedback are sourced from CLaaS Manager and embedded via iframe.
- Email delivery infrastructure is available for autograder feedback notifications.
- All AI-generated artifacts remain subject to human approval before learner exposure.

--- FEATURE LIST SUMMARY ---
This solution enables curriculum developers to design, generate, evaluate, and grade learning products end-to-end with autonomous AI agents handling content creation, rubric drafting, autograding, and framework alignment while humans approve every artifact. Primary actors are the Curriculum Developer, Product Admin, Instructional Designer, and Learner, supported by Content Generation, Rubric Authoring, Autograder Configuration, AutoGrader Engine, Curriculum Alignment, and Analytics agents. The flow runs from master data setup, through product/IU/KSA structuring, AI content and rubric authoring, autograder configuration, learner submission grading, framework gap analysis, and analytics. Master Data Configuration holds users, RBAC, courses, modules, taxonomies, prompts, and competency bands. The list contains 18 rows; top capabilities include agentic content authoring, prompt-driven autograding, and skills-framework alignment.

Feature Clusters & Features:
• Master Data Configuration
  - 1. User and RBAC Management — Maintains user accounts, auto-generated IDs, and role-based permissions enforced across every screen and agent action.
  - 2. Course and Module Catalogue Sync — Fetches courses, products, and modules from Product Apps via API with manual fallback when data is unavailable.
  - 3. Languages and Technologies Registry — Central reference list of supported languages and technology tags reused across modules, IUs, and content generation.
  - 4. Pedagogical Taxonomies Configuration — Configures proficiency goals, groupings, session modes, asset formats, content groupings, and assessment types used across the platform.
  - 5. Competency Level Bands — Defines grade bands (Basic, Foundation, Proficient, Expert) used by rubrics and autograders to compute learner scores.
  - 6. Content Type and Prompt Library — Stores content types with version-controlled generation, evaluation, and grading prompts driving every AI agent.
  - 7. TSC Skills Catalogue — Captures Technical Skills and Competencies entries with codes, categories, and linked knowledge and skills for curriculum mapping.
• Product Structure Authoring
  - 8. Module KSA Authoring — Lets developers define knowledge, skill, and ability items per module as the building blocks of learning outcomes.
  - 9. Instructional Unit and KSA Mapping — Creates IUs under each module and links the relevant knowledge, skill, and ability items to each unit.
  - 10. Session Plan Authoring — Captures per-IU session plans with mode, sub-type, duration, content repository link, and proficiency-competency grouping.
  - 11. Session Plan Copy — Clones a session plan with its KSAs, IUs, links, generated files, and autograder scripts into a target module.
• AI Content Generation
  - 12. Agentic Content Drafting — Content Generation Agent uses prompts, KSAs, and session context to draft instructional artifacts and write them to SharePoint.
  - 13. Content Review and Approval — Developers review, edit, regenerate, or approve AI-generated content before it becomes active for learners.
• Rubric and Autograder Authoring
  - 14. AI Rubric Authoring — Rubric Authoring Agent drafts evaluation rubrics aligned to competency bands and links them to content, IU, module, and course.
  - 15. Autograder Configuration Generation — Autograder Configuration Agent converts approved rubrics into grading prompts and scripts persisted as grading configurations.
• Learner Autograding Runtime
  - 16. Learner Submission Autograding — AutoGrader Engine grades learner files against the prompt, validates LLM responses, retries on failure, and emails feedback.
• Curriculum Framework Alignment
  - 17. Skills Framework Gap Analysis — Curriculum Alignment Agent compares the Product Plan to a country framework and recommends gap-closing remediations.
• Analytics and Agent Orchestration
  - 18. Analytics Dashboards and Agent Audit Log — Analytics Agent refreshes Power BI KPIs and charts; every agent action is logged for auditability and escalation review.

--- FEATURE LIST (18 features across 7 clusters) ---

#1 | Cluster: Master Data Configuration | Feature: User and RBAC Management
  Description: Central authority for user accounts, auto-generated IDs, and role-based access control. Every human and agent action is gated by these permissions.
  Workflow:
    1. Product Admin opens the User Management screen.
    2. Admin creates a user record; system auto-generates user ID.
    3. Admin assigns one or more RBAC roles (Admin, Developer, Designer).
    4. Permissions are persisted and enforced on every API call.
    5. Agents read role permissions before reading or writing records.
  Table:       users
  Columns:     user_id (bigint, pk), email (varchar 255, unique), full_name (varchar 200), role_code (varchar 50, fk), status (varchar 20), created_at (timestamp), updated_at (timestamp)
  Actor:       Product Admin
  AI Agent:    None
  ----
#2 | Cluster: Master Data Configuration | Feature: Course and Module Catalogue Sync
  Description: Maintains the canonical catalogue of courses, products, and modules with API-first sourcing and manual fallback. Provides the structural backbone for all downstream authoring.
  Workflow:
    1. Admin triggers sync from Product Apps API.
    2. System fetches Product Name, Code, Course, Product Plan, and Module Details.
    3. If API data exists, it overrides manual entries.
    4. If API call fails or returns empty, admin can create courses/modules manually.
    5. Course-Module mappings are persisted.
  Table:       courses
  Columns:     course_id (bigint, pk), product_code (varchar 50), course_code (varchar 50, unique), course_name (varchar 255), product_plan (text), source (varchar 20), synced_at (timestamp)
  Actor:       Product Admin
  AI Agent:    None
  ----
#3 | Cluster: Master Data Configuration | Feature: Languages and Technologies Registry
  Description: Central reference list of supported languages and technologies. Reused as filters and tags across content generation and product configuration.
  Workflow:
    1. Admin opens the Languages & Technologies screen.
    2. Admin adds a language or technology with code, name, and category.
    3. System validates uniqueness and persists.
    4. Entries become available as tags across modules, IUs, and content generation.
  Table:       languages_technologies
  Columns:     lt_id (bigint, pk), code (varchar 50, unique), name (varchar 150), type (varchar 30), is_active (boolean), created_at (timestamp)
  Actor:       Product Admin
  AI Agent:    None
  ----
#4 | Cluster: Master Data Configuration | Feature: Pedagogical Taxonomies Configuration
  Description: Configures the pedagogical taxonomies that drive curriculum structuring, session planning, and asset generation. Ensures consistent vocabulary across all products.
  Workflow:
    1. Instructional Designer opens taxonomy configuration.
    2. Designer creates Proficiency Goals, Groupings, Session Modes (with sub-types), Asset Format Types, Content Groupings, and Assessment Types.
    3. Each entry is uniquely coded and ordered.
    4. Entries become selectable across IU, session plan, and content authoring screens.
  Table:       taxonomy_entries
  Columns:     taxonomy_id (bigint, pk), taxonomy_type (varchar 50), code (varchar 50), label (varchar 200), parent_id (bigint, fk), order_index (int), is_active (boolean)
  Actor:       Instructional Designer
  AI Agent:    None
  ----
#5 | Cluster: Master Data Configuration | Feature: Competency Level Bands
  Description: Defines configurable grade bands per proficiency scheme. Used by rubric and autograder agents to translate raw scores into competency outcomes.
  Workflow:
    1. Designer opens Competency Level configuration.
    2. Designer selects scheme (Basic or Advanced).
    3. Designer defines grade bands with min and max percentages (e.g., Foundation 50-74).
    4. System validates non-overlapping ranges and persists.
    5. Bands are referenced by rubrics and autograder scoring.
  Table:       competency_levels
  Columns:     level_id (bigint, pk), scheme (varchar 20), band_label (varchar 50), min_pct (decimal), max_pct (decimal), order_index (int), is_active (boolean)
  Actor:       Instructional Designer
  AI Agent:    None
  ----
#6 | Cluster: Master Data Configuration | Feature: Content Type and Prompt Library
  Description: Stores content types and their version-controlled prompts that drive content generation, rubric drafting, and autograding. Single source of prompt truth for every agent.
  Workflow:
    1. Designer opens Content Type configuration.
    2. Designer creates a content type with asset format, content grouping, and applicable session modes.
    3. Designer attaches version-controlled generation, evaluation, and grading prompts.
    4. Prompts are stored with version metadata and activated for agent use.
  Table:       content_types
  Columns:     content_type_id (bigint, pk), code (varchar 50, unique), name (varchar 200), asset_format_id (bigint, fk), generation_prompt (text), evaluation_prompt (text), grading_prompt (text), prompt_version (varchar 20)
  Actor:       Instructional Designer
  AI Agent:    None
  ----
#7 | Cluster: Master Data Configuration | Feature: TSC Skills Catalogue
  Description: Captures Technical Skills and Competencies entries that anchor curriculum mapping. Powers KSA authoring and framework alignment.
  Workflow:
    1. Developer opens the TSC catalogue.
    2. Developer adds a TSC entry with code, title, category, and description.
    3. Developer attaches related knowledge and skill items.
    4. System validates code uniqueness and persists for downstream KSA mapping.
  Table:       tsc_entries
  Columns:     tsc_id (bigint, pk), tsc_code (varchar 50, unique), title (varchar 255), category (varchar 100), description (text), related_knowledge (text), related_skills (text), created_at (timestamp)
  Actor:       Curriculum Developer
  AI Agent:    None
  ----
#8 | Cluster: Product Structure Authoring | Feature: Module KSA Authoring
  Description: Lets developers define the knowledge, skill, and ability items per module. These items become the building blocks for IU mapping and content generation.
  Workflow:
    1. Developer opens a module.
    2. Developer adds knowledge, skill, and ability items with codes and descriptions.
    3. Developer sets order index and proficiency goal.
    4. System validates uniqueness within the module and persists.
  Table:       module_ksa
  Columns:     ksa_id (bigint, pk), module_id (bigint, fk), ksa_type (varchar 10), code (varchar 50), description (text), proficiency_goal_id (bigint, fk), order_index (int)
  Actor:       Curriculum Developer
  AI Agent:    None
  ----
#9 | Cluster: Product Structure Authoring | Feature: Instructional Unit and KSA Mapping
  Description: Creates Instructional Units beneath modules and maps the relevant KSA items. Defines the granular scope used by all AI generation agents.
  Workflow:
    1. Developer creates an IU under a module with code, title, and order.
    2. Developer selects relevant knowledge, skill, and ability items.
    3. System persists the IU and its KSA links.
    4. IU becomes available for session plan creation and content generation.
  Table:       instructional_units
  Columns:     iu_id (bigint, pk), module_id (bigint, fk), iu_code (varchar 50), title (varchar 255), order_index (int), ksa_ids (json), created_at (timestamp)
  Actor:       Curriculum Developer
  AI Agent:    None
  ----
#10 | Cluster: Product Structure Authoring | Feature: Session Plan Authoring
  Description: Captures session plans per IU with mode, content type, duration, and grouping. Provides the configuration context every AI agent reads when generating artifacts.
  Workflow:
    1. Developer opens an IU and creates a session plan.
    2. Developer selects session mode, sub-type, content type, and duration.
    3. Developer attaches the SharePoint content repository link.
    4. Developer maps the plan to a Proficiency-Competency Grouping.
    5. System persists session plan with internal and external review links.
  Table:       session_plans
  Columns:     session_plan_id (bigint, pk), iu_id (bigint, fk), session_mode_id (bigint, fk), sub_type (varchar 50), content_type_id (bigint, fk), duration_min (int), repo_link (varchar 500), grouping_id (bigint, fk)
  Actor:       Curriculum Developer
  AI Agent:    None
  ----
#11 | Cluster: Product Structure Authoring | Feature: Session Plan Copy
  Description: Clones a session plan with all dependent KSAs, IUs, files, and autograder scripts into a target module. Accelerates reuse of vetted content across products.
  Workflow:
    1. Developer selects a source session plan and a target module.
    2. System clones session plan attributes, KSA links, and IU references.
    3. System duplicates generated content files, rubrics, and autograder scripts.
    4. New IDs are assigned; relationships are rewired to the target module.
    5. Developer reviews the cloned structure and adjusts as needed.
  Table:       session_plan_copies
  Columns:     copy_id (bigint, pk), source_plan_id (bigint, fk), target_module_id (bigint, fk), new_plan_id (bigint, fk), copied_artifacts (json), copied_by (bigint, fk), copied_at (timestamp)
  Actor:       Curriculum Developer
  AI Agent:    None
  ----
#12 | Cluster: AI Content Generation | Feature: Agentic Content Drafting
  Description: Content Generation Agent autonomously drafts instructional artifacts based on configured prompts and writes them to SharePoint. Every output is flagged for developer approval before activation.
  Workflow:
    1. Developer triggers content generation for a session plan.
    2. Content Generation Agent loads the content-type prompt, KSAs, technologies, and grouping.
    3. Agent calls the LLM and renders the artifact in the required format.
    4. Agent writes the file to SharePoint and records file ID, link, name, tags, method, and order.
    5. Record is flagged as AI-generated, pending review.
  Table:       generated_content
  Columns:     content_id (bigint, pk), session_plan_id (bigint, fk), sharepoint_file_id (varchar 100), file_link (varchar 500), file_name (varchar 255), tags (json), generation_method (varchar 30), order_index (int), status (varchar 20), created_at (timestamp)
  Actor:       Content Generation Agent
  AI Agent:    Content Generation Agent
  ----
#13 | Cluster: AI Content Generation | Feature: Content Review and Approval
  Description: Developers review and approve every AI-generated artifact before it is exposed to learners. Maintains pedagogical quality and human-in-the-loop control.
  Workflow:
    1. Developer opens the pending-review queue.
    2. Developer previews the generated artifact.
    3. Developer approves, edits inline, or requests regeneration with feedback.
    4. On approval, the content status flips to active and is published to learners.
    5. Approval action is logged with timestamp and reviewer ID.
  Table:       content_reviews
  Columns:     review_id (bigint, pk), content_id (bigint, fk), reviewer_id (bigint, fk), action (varchar 20), comments (text), reviewed_at (timestamp), new_status (varchar 20)
  Actor:       Curriculum Developer
  AI Agent:    Content Generation Agent
  ----
#14 | Cluster: Rubric and Autograder Authoring | Feature: AI Rubric Authoring
  Description: Rubric Authoring Agent drafts evaluation rubrics aligned to competency level bands and persists them with full curriculum linkage. Provides the scoring scaffold for autograding.
  Workflow:
    1. Developer triggers rubric generation for an approved content item.
    2. Rubric Authoring Agent loads the evaluation prompt and competency bands.
    3. Agent drafts the rubric mapped to the bands and saves it to SharePoint.
    4. Agent links the rubric to content, IU, module, and course.
    5. Record is flagged as pending review.
  Table:       rubrics
  Columns:     rubric_id (bigint, pk), content_id (bigint, fk), course_id (bigint, fk), module_id (bigint, fk), iu_id (bigint, fk), sharepoint_file_id (varchar 100), bands_json (json), status (varchar 20), created_at (timestamp)
  Actor:       Rubric Authoring Agent
  AI Agent:    Rubric Authoring Agent
  ----
#15 | Cluster: Rubric and Autograder Authoring | Feature: Autograder Configuration Generation
  Description: Autograder Configuration Agent converts approved rubrics into actionable grading prompts and scripts. Persists a reusable grading configuration tied to the session plan.
  Workflow:
    1. Developer triggers autograder configuration for an approved rubric.
    2. Autograder Configuration Agent translates the rubric into a grading prompt and script.
    3. Agent persists a grading configuration record with course, module, IU, and session plan references.
    4. Agent stores prompt file metadata and script artifact links.
    5. Developer reviews, edits if needed, and approves the configuration.
  Table:       grading_configurations
  Columns:     grade_conf_id (bigint, pk), session_plan_id (bigint, fk), course_id (bigint, fk), module_id (bigint, fk), iu_id (bigint, fk), rubric_id (bigint, fk), prompt_file_id (varchar 100), grading_script_link (varchar 500), status (varchar 20)
  Actor:       Autograder Configuration Agent
  AI Agent:    Autograder Configuration Agent
  ----
#16 | Cluster: Learner Autograding Runtime | Feature: Learner Submission Autograding
  Description: AutoGrader Engine grades learner submissions against the configured prompt with retry and validation guardrails. Persists auditable grading results and triggers learner feedback emails.
  Workflow:
    1. Submission arrives with learner email, cohort code, and file.
    2. AutoGrader Engine creates grade_sub_id linked to the grading configuration.
    3. Engine sends prompt + file to LLM and validates the response.
    4. On invalid response, engine retries up to process_attempt_count and logs each attempt.
    5. On success, engine computes band, marks completion, and dispatches feedback email; on repeated failure, escalates to human grader.
  Table:       grading_submissions
  Columns:     grade_sub_id (bigint, pk), grade_conf_id (bigint, fk), learner_email (varchar 255), cohort_code (varchar 50), submission_file_id (varchar 100), openai_response (text), is_openai_response_valid (boolean), score (decimal), band_label (varchar 50), is_grading_completed (boolean), is_email_sent (boolean), process_attempt_count (int), attempt_logs (json), created_at (timestamp)
  Actor:       AutoGrader Engine Agent
  AI Agent:    AutoGrader Engine Agent
  ----
#17 | Cluster: Curriculum Framework Alignment | Feature: Skills Framework Gap Analysis
  Description: Curriculum Alignment Agent compares the Product Plan against a country-specific skills framework and recommends fixes for identified gaps. Helps ensure regulatory and market alignment.
  Workflow:
    1. Developer selects a country and loads the Product Plan.
    2. Curriculum Alignment Agent loads the country's skills framework.
    3. Agent compares Product Plan items to framework competencies.
    4. Agent highlights aligned items and gaps and generates remediation recommendations.
    5. Developer reviews, accepts, or iterates recommendations into product structure.
  Table:       framework_alignments
  Columns:     alignment_id (bigint, pk), country_code (varchar 10), product_plan_id (bigint, fk), aligned_items (json), gap_items (json), recommendations (json), generated_at (timestamp), reviewed_by (bigint, fk)
  Actor:       Curriculum Alignment Agent
  AI Agent:    Curriculum Alignment Agent
  ----
#18 | Cluster: Analytics and Agent Orchestration | Feature: Analytics Dashboards and Agent Audit Log
  Description: Analytics Agent refreshes Power BI dashboards while a unified audit log captures every agent action, retry, and escalation. Provides observability and accountability for the agentic platform.
  Workflow:
    1. Analytics Agent aggregates platform telemetry on a schedule.
    2. Agent refreshes Power BI KPIs (Total Users, Active Sessions, Modules Created), Content Volume, User Distribution, and Recent Activity.
    3. Embedded learner-feedback report is fetched from CLaaS Manager via iframe.
    4. Every agent action across the platform is logged with timestamp, agent ID, prompt, and outcome.
    5. Escalations and stop-condition triggers are surfaced for developer review.
  Table:       agent_audit_logs
  Columns:     log_id (bigint, pk), agent_name (varchar 100), action_type (varchar 50), entity_type (varchar 50), entity_id (bigint), prompt_version (varchar 20), outcome (varchar 30), details (json), occurred_at (timestamp)
  Actor:       Analytics Agent
  AI Agent:    Analytics Agent
  ----

==================================================
 END OF STORY EXPORT
==================================================
