Description:FIELD OF INVENTION
The present invention relates to the field of software engineering and project management systems, and more particularly to a system and method for continuous multi-factor prioritization of requirements or features in agile release planning using sentiment analysis, risk evaluation, and dependency assessment.
BACKGROUND
Agile release planning is a flexible approach where development teams map out and schedule incremental releases of a product's features over a period, rather than planning a single, massive launch. It prioritizes features based on business value, fosters collaboration among team members and stakeholders, and adapts to changes by incorporating customer feedback from earlier iterations. This iterative process allows teams to deliver value frequently, gather feedback, and stay competitive.
Conventional agile planning tools (e.g., JIRA, Azure DevOps) allow manual prioritization of backlog items using static field such as “Story Points” or “Business Value”. Existing AI-assisted estimators focus mainly on effort prediction (e.g., using historical velocity) but do not integrate sentiment analysis, dependency graphs, or dynamic capacity forecasting into a unified re-prioritization loop. Some research prototypes (e.g., “Risk-based Sprint planning” and “Sentiment-Driven Backlog Mining”) treat each factor in isolation and lack a continuous optimization engine that updates the release plan as new data arrives.
PRIOR ART
CN109033843B discloses the invention discloses a Java file dependency analysis method and a Java file dependency analysis module for a distributed static detection system, wherein the method comprises the following steps: processing information for all files in the program package; reading a Java source code file in all files; generating an abstract syntax tree of the file; performing dependency analysis on all statements of the file to find out other files on which the file depends; recording the dependency relationship between the file and other files; judging whether all files have been subjected to dependency analysis.

US11277432B2 discloses a system and method that implements a state graph representative of a set of action states within a network, each action state representing an attack that can be performed by an adversary within the network, determining a path stealthiness value for each attack path of a set of attack paths within the network, path stealthiness values being determined based on a mapping that maps each action state to one or more technique-tactic pairs and one or more security controls, determining a path hardness value for each attack path of the set of attack paths within the network, path hardness values being determined based on a state correlation matrix that correlates action states relative to each other, and a decay factor that represents a reduction in effort required to repeatedly perform an action of an action state, and selectively generating one or more alerts based on one or more of path stealthiness values and path hardness values.

Though the prior art talks about agile planning but the problems with the prior arts are first, static prioritization that leads to mis-aligned releases when stakeholder expectations shift or when unforeseen risks emerge. Second is manual re-prioritization is time-consuming and error-prone, especially for large backlogs with complex dependencies, further capacity forecasting is typically based on historical velocity alone, ignoring upcoming holidays, team-skill changes or non-project work. Next is sentiment extraction from informal communication (chat, email) is not leveraged to influence planning decisions, despite its proven correlation with project success.

Therefore, a system is needed that automatically, continuously, and scalable integrates risk, dependency, stakeholder sentiment, and capacity into a mathematically grounded prioritization engine, delivering a rolling, optimal release plan while remaining explainable to product owners and stakeholders.
DEFINITIONS
The expression “system” used hereinafter in this specification refers to an ecosystem comprising, but not limited to, system for automatically defining post-deployment success metrics with input and output devices, processing unit, plurality of mobile devices, a mobile device-based application. It is extended to computing systems like mobile phones, laptops, computers, PCs, and other digital computing devices.
The term “input unit” used hereinafter in this specification refers to, but is not limited to, mobile, laptops, computers, PCs, keyboards, mouse, pen drives or drives.
The term “processing unit” refers to the computational hardware or software that performs the data base analysis, generation of graphs, detection of dead code, processing, removal of dead code, and like. It includes servers, CPUs, GPUs, or cloud-based systems that handle intensive computations.
The term “output unit” used hereinafter in this specification refers to hardware or digital tools that present processed information to users including, but not limited to computer monitors, mobile screens, printers, or online dashboards.
The term “agile” used hereinafter in this specification refers to a development approach that emphasizes iterative work, collaboration, customer feedback, and rapid delivery of valuable software increments.
The term “ARIMA” or “Autoregressive Integrated Moving Average” used hereinafter in this specification refers to a statistical time series forecasting model that uses past data to predict future trends.
The term “LSTM” or “Long Short-Term Memory” used hereinafter in this specification refers to a type of recurrent neural network (RNN) designed to handle sequential data by learning long-term dependencies,
The term “Natural Language Processing” or “NLP” used hereinafter in this specification refers to a machine learning system built to understand, interpret, and generate human language, whether written or spoken.
OBJECTS OF THE INVENTION
The object of the present invention is to provide a system and method for continuous multi-factor prioritization engine using sentiment, risk and dependency analysis for agile release planning.
Another object of the invention is to provide a data ingestion layer that harvests backlog items, dependency metadata, historical execution data, team-capacity calendars and unstructured communication streams.
Yet another object of the invention is to provide a sentiment-mining engine that maps each stakeholder’s utterance to a sentiment score Si per backlog item, with confidence weighting.
Yet another object of the invention is to provide a risk-qualification module that combines failure probability pf, impact magnitude l, and uncertainty variance into a risk weight.
Yet another object of the invention is to provide a capacity-forecast engine that ingests calendar events, historical velocity and skill-availability vectors to generate a future capacity vector for each upcoming sprint/week.
Yet another object of the invention is to provide a composite scoring function for each backlog item i at time t, the engine computes a priority score.
Yet another object of the invention is to provide a rolling optimizer a constrained integer-liner programming solver that selects a subset of the items for each future sprint while respecting capacity, dependency and regulatory constraints.
Yet another object of the invention is to provide an explainability dashboard that visualizes the contribution of each factor to the final score, provides “what-if” simulation and emits a release plan document.
SUMMARY
Before the present invention is described, it is to be understood that the present invention is not limited to specific methodologies and materials described, as these may vary as per the person skilled in the art. It is also to be understood that the terminology used in the description is for the purpose of describing the particular embodiments only and is not intended to limit the scope of the present invention.
The present invention describes a computer implemented system and method for continuously generating a rolling release plan for agile software development. The system ingests backlog items, dependency data, historical execution metrics, team capacity forecasts, and unstructured stakeholder communications. The system describes a Context Sensitive Requirement Engine that integrates state of the art statistical NLP, generative AI, graph analytics, and reinforcement learning to deliver an always current, bidirectional traceability graph between natural language artifacts and source code. By automating requirement extraction, normalization, and impact analysis, the system reduces manual engineering effort, improves compliance, and yields a substantial return on investment for software intensive enterprises.
According to an aspect of the present invention, the system comprises of an input unit , a processing unit and output unit , wherein the processing unit comprises of Priority Weighted Storyboard Scheduler (PWSS) that further comprises of Data Ingestion Layer, Sentiment Mining Engine , Risk Quantification Module , Dependency Graph Analyzer , Capacity Forecast Engine ,Composite Scoring Function , Rolling Optimizer , and Explainability Dashboard. The invention provides the Priority Weighted Storyboard Scheduler (PWSS) that is implemented as a microservice-based system, which continuously ingests multi-source data and generates rolling optimized release plans. The core novelty lies in integrating sentiment-derived weights with risk-aware, dependency-constrained, and capacity-aware optimization in a continuous feedback loop.
BRIEF DESCRIPTION OF DRAWINGS
A complete understanding of the present invention may be made by reference to the following detailed description which is to be taken in conjugation with the accompanying drawing. The accompanying drawing, which is incorporated into and constitutes a part of the specification, illustrates one or more embodiments of the present invention and, together with the detailed description, it serves to explain the principles and implementations of the invention.
Fig. 1 High level system architecture of PWSS showing data sources, processing pipelines, and output interfaces.
Fig. 2 Flowchart of the Sentiment Mining Engine (pre processing → transformer inference → confidence weighting).
Fig. 3 DAG representation of backlog dependencies and the algorithm for computing the Dependency Factor.
Fig. 4 Block diagram of the Composite Scoring Function, illustrating how the weighted terms are combined.
Fig. 5 ILP formulation diagram: decision variables, objective, and constraints (capacity, dependency, deadline).
Fig. 6 Sample UI of the Explainability Dashboard (score breakdown, what if sliders, rolling release Gantt).
Fig. 7 Reinforcement learning loop that adapts hyper parameters based on observed Release Success Utility.
DETAILED DESCRIPTION OF INVENTION:
Before the present invention is described, it is to be understood that this invention is not limited to methodologies described, as these may vary as per the person skilled in the art. It is also to be understood that the terminology used in the description is for the purpose of describing the particular embodiments only and is not intended to limit the scope of the present invention. Throughout this specification, the word “comprise”, or variations such as “comprises” or “comprising”, will be understood to imply the inclusion of a stated element, integer or step, or group of elements, integers or steps, but not the exclusion of any other element, integer or step, or group of elements, integers or steps. The use of the expression “at least” or “at least one” suggests the use of one or more elements or ingredients or quantities, as the use may be in the embodiment of the invention to achieve one or more of the desired objects or results. Various embodiments of the present invention are described below. It is, however, noted that the present invention is not limited to these embodiments, but rather the intention is that modifications that are apparent are also included.
The present invention describes a computer implemented system and method for continuously generating a rolling release plan for agile software development. The system ingests backlog items, dependency data, historical execution metrics, team capacity forecasts, and unstructured stakeholder communications. The system describes a Context Sensitive Requirement Engine that integrates state of the art statistical NLP, generative AI, graph analytics, and reinforcement learning to deliver an always current, bidirectional traceability graph between natural language artifacts and source code. By automating requirement extraction, normalization, and impact analysis, the system reduces manual engineering effort, improves compliance, and yields a substantial return on investment for software intensive enterprises.
According to the embodiment of the present invention, the system comprises of an input unit , a processing unit and output unit , wherein the processing unit comprises of Priority Weighted Storyboard Scheduler (PWSS) that further comprises of Data Ingestion Layer, Sentiment Mining Engine , Risk Quantification Module , Dependency Graph Analyzer , Capacity Forecast Engine ,Composite Scoring Function , Rolling Optimizer , and Explainability Dashboard. The invention provides the Priority Weighted Storyboard Scheduler (PWSS) that is implemented as a microservice-based system, which continuously ingests multi-source data and generates rolling optimized release plans. The core novelty lies in integrating sentiment-derived weights with risk-aware, dependency-constrained, and capacity-aware optimization in a continuous feedback loop.
According to the embodiment of the present invention, the Priority Weighted Storyboard Scheduler (PWSS) comprises the following modules:
1. Data Ingestion Layer: This has connectors that harvest backlog metadata, dependency information, historical execution data, team capacity calendars, and unstructured communication streams.
2. Sentiment Mining Engine: This is a transformer-based generative AI model that that maps each stakeholder’s utterances to a Sentiment Score (Si) per backlog item, with confidence weighting.
3. Risk Quantification Module – This computes a probabilistic risk weight by combining failure probability (pf), impact magnitude (I), and uncertainty variance (σ2) into a Risk Weight Ri = pf ⋅ I ⋅ (1 + σ).
4. Dependency Graph Analyzer – This constructs a directed acyclic graph of item to item dependencies and computes a Topological Priority Factor (Di) using critical path analysis and edge weight attenuation.
5. Capacity Forecast Engine – applies hybrid ARIMA-LSTM models that ingests calendar events, historical velocity, and skill availability vectors to generate a Future Capacity Vector (Ct) for each upcoming sprint/week.
6. Composite Scoring Function – This computes a Priority score for each backlog item i at time t,

where α,β,γ,δ,ϵ are tunable hyper parameters learned via reinforcement learning (RL) to maximize a Release Success Utility (RSU) defined below.
7. Rolling Optimizer: This is a constrained integer linear programming (ILP) solver (or a mixed integer quadratic program) that, given Πi,t and Ct, selects a subset of items for each future sprint while respecting capacity, dependency, and regulatory constraints.
8. Explainability Dashboard: This dashboard visualizes the contribution of each factor to the final score, provides “what if” simulation (adjust α ϵ or inject new sentiment), and emits a Release Plan Document (JSON, PDF, Gantt).
The PWSS continuously re-evaluates scores as new data streams arrive, automatically re-optimizing the plan and notifying stakeholders of changes.
According to the embodiment of the present invention, the Data Ingestion Layer serves as the foundational module of the Priority Weighted Storyboard Scheduler (PWSS). Its primary function is to collect, normalize, and persist all relevant input data from heterogeneous sources, thereby ensuring that subsequent modules operate on unified and consistent representations. It comprises of
• Backlog Connector that connects to Agile Lifecycle Management (ALM) systems such as Jira, Azure DevOps, Rally, or equivalent tools. Through REST or GraphQL APIs, it extracts backlog items including unique identifier, title, detailed description, assigned story points, business value, due date, and current status. This information forms the initial candidate set of backlog items to be scored.
• Dependency Extractor that automatically parses links and traceability metadata such as “blocked by,” “depends on,” or “relates to.” It also analyzes code-level call graphs and requirement traceability matrices to infer implicit dependencies. The output is a Directed Acyclic Graph (DAG) representation, denoted as G(V,E), where each vertex represents a backlog item and each directed edge indicates a dependency relationship.
• Capacity Calendar aggregates information from enterprise calendars such as Outlook or Google Calendar. It integrates paid-time-off (PTO) records, training schedules, and skill matrices (stored in JSON format) to generate availability vectors Ar(t) for each team member r at time t.
• Communication Stream Processor employs Apache Kafka or equivalent streaming infrastructure to ingest unstructured communication data from collaboration platforms such as Slack, Microsoft Teams, and email servers. Messages are subjected to de-identification for privacy and stored in an immutable audit log. These messages form the raw material for sentiment mining.
By combining structured backlog metadata with unstructured communication and capacity data, the Data Ingestion Layer establishes a comprehensive knowledge base required for prioritization.

According to the embodiment of the present invention, the Sentiment Mining Engine maps stakeholder utterances to sentiment values associated with backlog items. Unlike traditional sentiment tools, the engine is designed to function in the domain-specific environment of software development discussions, which frequently involve technical jargon, abbreviations, and context-specific meanings. It comprises of:
• Pre-processing: Text streams are tokenized, stop words removed, and entities normalized. User handles are mapped to unique stakeholder identifiers. Personally Identifiable Information (PII) is stripped to comply with data protection regulations.
• Model Architecture: The engine employs a dual-encoder architecture:
a. A topic encoder, fine-tuned on software development vocabularies, ensures correct mapping of technical references to backlog items.
b. A sentiment encoder, fine-tuned on domain-specific sentiment corpora such as annotated Slack data, classifies sentiment into positive, neutral, and negative categories.
• Message-Level Scoring: Each message m referencing backlog item i yields a probability distribution:
pm=[ppos,pneu,pneg]
The Message Sentiment Score (sm) is defined as:
sm=ppos−pneg
• Aggregation: Over a sliding time window W (e.g., last 24 hours), the sentiment for item i is:

where wm is a confidence weight derived from the model’s softmax entropy and stakeholder authority (e.g., product owner > developer).
• Drift Detection: A CUSUM (Cumulative Sum) statistical test continuously monitors the time shifts Si,t. If sudden deviations are detected, the optimizer is re-triggered immediately.
Thus, sentiment is captured as a quantitative, time-sensitive signal contributing directly to item prioritization.
According to the embodiment of the present invention, the Risk Quantification Module transforms uncertain project risks into numerical weights. It comprises of:
• Failure Probability (pf): Derived from historical defect density, change impact analysis, and external risk registers.
• Impact Magnitude (I): A weighted matrix of regulatory, financial, and customer-experience impact scores is used to calculate severity.
• Uncertainty (σ): Standard deviation computed from Monte Carlo simulations of input parameters.
The resulting Risk Weight is given by:
Ri,t=pf × I × (1+σ)
Risk scores are recalculated periodically, typically once per sprint, but may also be updated on-demand based on incoming telemetry.
According to the embodiment of the present invention, the Dependency Graph Analyzer prevents scheduling blocked work. It constructs a topological order τ over DAG G(V,E). It also computes the Criticality Index (CIi) for each node i:

The Dependency Penalty is Di = λ × CIi
where λ is a product-owner-adjustable scaling factor. Higher CIi values indicate higher blocking potential, thus reducing scheduling priority.
According to the embodiment of the present invention, the Capacity Forecast Engine estimates available effort in upcoming sprints. It employs hybrid ARIMA (seasonality) and LSTM (non linear trend) trained on historical sprint velocity to capture both seasonality and non-linear trends adjusted for team composition changes. It also applies a skill-fit adjustment: multiplies forecasted capacity by a skill fit coefficient derived from a cosine similarity between required skill vectors of selected items and available skill vectors of team members.
Output: Vector Ct = [ct,1, ct,2,...,ct,T] where ct,k is the forecasted capacity for sprint k starting at time t.
According to the embodiment of the present invention, the Composite scoring function is evaluated per item, per sprint. For each backlog item i at time t, the Composite Priority Score is:

• Si = sentiment score
• Ri = risk weight
• Di = dependency penalty
• Ct = capacity factor
• Ui = urgency factor (deadline proximity or business-driven urgency)
• α–ϵ = tunable hyperparameters
These hyper parameters are learned by a policy gradient reinforcement learning (RL) agent, which receives as reward a Release Success Utility (RSU) defined as:

The agent updates α–ϵ after each sprint to maximize cumulative RSU.
According to the embodiment of the present invention, the Rolling Optimizer selects backlog items for each sprint. It is formulated as an Integer Linear Programming (ILP) problem:

The ILP is solved each time a new data point arrives (or on a fixed schedule, e.g., every 4 h) using a commercial solver (Gurobi, CPLEX) or an open source alternative (COIN OR). The solution yields a rolling release plan that can be exported to the team’s ALM tool via API.
According to the embodiment of the present invention, the Explainability Dashboard improves stakeholder trust and adoption. It comprises
• Score Decomposition: stacked bar chart per item showing contribution of each term of Πi,t.
• What-If Simulation: allows users to adjust α–ϵ or inject new sentiment data and instantly observe optimizer output.
• Change Log: timestamps of sentiment spikes, risk updates, or capacity revisions that triggered plan changes.
• Export Features: generates JSON/CSV files for machine use and PDF Gantt charts for management presentations.
According to the embodiment of the present invention the method for real time re prioritization of a software development backlog, comprises the steps of:
a) receiving, in real time, stakeholder communication data;
b) extracting sentiment scores for each backlog item using a generative AI language model;
c) computing risk weights for each item from probabilistic risk parameters;
d) constructing a dependency graph and determining dependency penalties;
e) forecasting future development capacity for upcoming sprints;
f) calculating a composite priority score for each item using a weighted sum of business value, risk, sentiment, dependency, and urgency;
g) solving, for each future sprint, a constrained optimization problem that maximizes the sum of priority scores while respecting capacity, dependency, and deadline constraints; and
h) outputting a rolling release schedule and visual explanations of score contributions.
Steps b)–g) are repeated each time new data becomes available.
Training data characteristics
1.1 Sources and composition
In one embodiment, the PWSS is trained and evaluated on a multi-modal corpus composed of:
• Backlog/ALM artifacts: 80k–750k items from Jira/Azure DevOps/Rally with fields {id, title (~12 tokens), description (~120 tokens), labels, links, dependencies, business value V, story points, due date}.
• Stakeholder communications: 1.2M–12M messages from Slack/Teams/email threads associated to projects via channel/project keys and URL issue mentions. Average length 18–42 tokens; 15–25% include code snippets or stack traces.
• Execution telemetry: 20k–200k historical sprint records (velocity, spillover, carryover, unplanned work, interruptions/outages).
• Calendars & skills: Per-member PTO and meeting calendars (RFC 5545 iCalendar export) and a skill matrix (JSON) of ~5–50 skills per individual with proficiency in {0..3}.
• Risk logs/incidents: 5k–40k incidents/defects with fields (severity, root cause, component, remediation time).
• Dependency graphs: From ALM links and static analysis of code repositories (call graphs, package imports); typical graph sizes 5k–60k nodes, average out-degree 1.7–3.2.
1.2 Labeling & gold standards
• Sentiment labels: A stratified sample of 50k–120k messages is human-annotated as {positive, neutral, negative} toward a specific backlog item. Annotators see message + immediate thread context (±3 messages). Inter-annotator agreement is measured with Cohen’s κ (target κ≥0.72).
• Topic relevance labels: For 30k message–item pairs, annotators mark whether the message is “about” item i. These are used for training the topic encoder and for hard negative mining.
• Capacity ground truth: Historical capacities per sprint (team-level story points) serve as regression targets.
• Risk priors: Post-incident attributions (e.g., “payment gateway regression”) are used to set/validate conditional probabilities in a Bayesian network (see §3).
1.3 Privacy & governance
All communications are de-identified prior to modeling:
• Named entities (PERSON, EMAIL, PHONE, ACCOUNTS) replaced with consistent placeholders (e.g., ).
• Channel and user IDs are salted-hashes.
• Messages marked “confidential/legal” are excluded.
• An allow-list of domains and channels gates ingestion.
An immutable audit log stores hashes and model version IDs for reproducibility.
2.1 Normalization (communications & ALM text)
1. Canonicalization: Unicode NFC, lowercase (except code blocks), collapse whitespace.
2. Tokenization: WordPiece/BPE (vocab 30k–50k).
3. Code-aware handling: Inline code fenced with backticks is replaced by a single token; long code blocks are summarized via a 256-token truncation with entropy-based sentence selection.
4. URL & artifact linking: Expand shortened URLs; regex for issue keys (e.g., PROJ-123) is resolved through ALM API to attach candidate item IDs.
5. Stopword & boilerplate: Remove signatures/footers with heuristic regex; preserve negations (“not”, “isn’t”).
6. Stakeholder mapping: Map sender to a stakeholder role (PO, QA, Dev, Architect, Exec) used later as an authority weight.
7. Time windowing: Assign each message to a sliding window W (e.g., last 24–168 hours) for aggregation.
2.2 Feature assembly (per item i, time t)
• Sentiment features: message-level logits, calibrated probabilities, confidence (entropy), author role.
• Dependency features: node degree, betweenness centrality, path length to release blockers, critical path length.
• Capacity features: holiday flags, meeting load (minutes), PTO hours, team composition deltas, seasonality indices (week-of-quarter), recent velocity EMA(α=0.3).
• Urgency features: days to deadline, SLA class, regulatory tag.
3) AI models and learning mechanisms
3.1 Dual-encoder for topic relevance (message → backlog item)
Purpose: Precisely map informal messages to the correct backlog item despite jargon and ambiguity.
• Architecture: Two transformer encoders (e.g., RoBERTa-base or DeBERTa-v3-base; 12 layers, hidden=768, heads=12, GELU activations, LayerNorm, dropout=0.1).
o Encoder E_m for message text (≤256 tokens).
o Encoder E_i for item title+description (≤256 tokens).
o Mean-pooling over final hidden states to obtain vectors u = E_m(m) and v = E_i(i), L2-normalized.
• Similarity: cosine(u, v).
• Loss: InfoNCE contrastive loss with in-batch negatives and hard-negative mining from items sharing labels/components:

with temperature τ∈[0.02, 0.1].
• Optimization: AdamW (β₁=0.9, β₂=0.999, weight decay 0.01), batch 256 pairs, 3–5 epochs, cosine LR schedule with 10% warmup, base LR 2e-5.
• Inference: ANN index (HNSW, efSearch 64) over item vectors for sub-10 ms retrieval per message.
Technical effect: Robust item mapping reduces topic leakage and erroneous sentiment attribution, directly lowering prioritization noise and re-planning churn (§7.2).
3.2 Sentiment encoder (domain-specific)
Purpose: Capture stakeholder affect in a software-engineering context (e.g., “this PR is brittle” → negative).
• Backbone: Transformer (e.g., RoBERTa-large, 24 layers, hidden=1024) further pre-trained on in-domain corpora (engineering chats, commit messages) with masked-language modeling (MLM) for 100k–500k steps (LR 1e-4 → 1e-5).
• Head: 3-way classifier (positive/neutral/negative), hidden→dropout(0.1)→Linear(1024→3).
• Activation/Loss: Softmax with class-weighted cross-entropy (weights inversely proportional to class frequency) or focal loss (γ=2.0) for imbalance.
• Calibration: Temperature scaling on validation to produce well-calibrated p(pos/neu/neg).
• Confidence: 1 − normalized entropy of the softmax; used as a weight wmw_mwm.
• Authority weighting: Multiply wmw_mwm by role factor ρ_r (e.g., PO=1.5, Exec=1.3, QA=1.2, Dev=1.0; tunable).

with drift detection via CUSUM; exceeding threshold triggers immediate re-optimization.
Technical effect: Converts high-velocity, noisy comms into a calibrated, time-sensitive signal that anticipates expectation shifts earlier than formal fields.
3.3 Risk quantification with Bayesian network + Monte Carlo
Purpose: Predict failure probability for items considering code churn, complexity, and integration points.
• Variables: {Historical defect rate, cyclomatic complexity, dependency fan-in/fan-out, developer experience on module, test coverage, external API stability}.
• Structure: Learned via score-based search (BIC) constrained by domain DAG priors; parameters fit with maximum likelihood + Laplace smoothing.
• Output: pf(i) per item.
• Impact I(i): Weighted sum of regulatory severity, financial exposure, and customer reach (weights set with AHP and validated quarterly).
• Uncertainty σ(i): Std. dev. of the P90–P10 interval from Monte Carlo (N=10,000) simulations over parameter posteriors.
• Risk weight: Ri,t = pf(i) ⋅ I(i) ⋅ (1+σ(i)).
Technical effect: Formalizes risk under uncertainty; discourages scheduling risky items together, reducing defect leakage.
3.4 Dependency Graph Analyzer
Purpose: Penalize items whose delay would block many others.
• Graph: DAG G = (V,E)
• Criticality Index (CI):

where ωuv attenuates weaker edges (0.5–1.0).
• Penalty: Di = λ ⋅ CIi with λ ∈ [0.1,2].
• Computation: Topological pass with dynamic programming; complexity O(∣E∣)
Technical effect: Reduces blocked work and rework from out-of-order scheduling.
3.5 Capacity Forecast Engine (hybrid ARIMA-LSTM with skill fit)

3.6 Composite scoring and normalization
Each raw factor is z-scored to zero-mean/unit-variance per project window to avoid scale dominance:

3.7 Rolling optimizer (ILP)

Technical effect: Guarantees globally optimal schedules under evolving constraints, unlike greedy/manual methods.
3.8 RL for coefficient adaptation
Agent: Policy gradient (REINFORCE) or PPO over continuous parameters θ = [α,β,γ,δ] constrained to α + β + γ + δ + ϵ = 1 via softmax.
• State st: Recent delivery stats (on-time %, spillover), sentiment volatility, risk distribution skew, capacity error (forecast vs actual).
• Action at: Update θ producing new weights for next planning cycle.
• Reward (Release Success Utility, RSU):

Coefficients η chosen per org policy.
• Training: Rollouts over historical quarters (offline) + online updates with KL-penalty to limit sudden changes.
Technical effect: Automatically tunes trade-offs (e.g., risk vs sentiment) to environmental drift, reducing human retuning effort.

10. The system and method as claimed in claim 1,wherein the Priority Weighted Storyboard Scheduler is implemented as a microservice-based system, which continuously ingests multi-source data and generates rolling optimized release plans, thus integrating sentiment-derived weights with risk-aware, dependency-constrained, and capacity-aware optimization in a continuous feedback loop.