Skip to main content

Scope overview

Use this overview to understand the agreed scope operating model before proposing, approving or handing off AeroSim work. Jira owns current tickets, product scope, decisions and state. This page explains the process; it is not a backlog, release matrix or copy of ticket content.

Open the work in Jira​

The project, named versions and example parent links were checked through the Jira API on 2026-11-09. These links do not certify migration completeness, release acceptance or browser access for every reader.

Ticket hierarchy and authority​

Epic → Feature → implementation Task is the delivery hierarchy. An Epic groups a product outcome; a Feature defines a user-visible capability, bounded scope and observable acceptance outcomes; a Task defines exact implementation and verification work. Preserve both the Jira key and stable AeroSim identity. Jira currently represents the linked example implementation Task as a Subtask beneath its Feature; use the exact issue type rather than assuming every Task has the same workflow.

Functional Requirements have their sole canonical home in CogArch (Cognitive Architect). Link Features to their canonical architecture; do not create FR tickets or copy FR bodies into Jira. Ideas remain outside Jira under the agreed exclusion. Retained source files are historical evidence, not a second current scope registry.

Cumulative release scope​

The agreed model is Release → release-specific Epic → release-specific Feature. Each release carries all prior Epics and Features, including unchanged scope.

  • Keep one Jira Epic/Feature instance for each (canonical ID, release ID) pair, with one native Fix Version association. A Feature belongs to the Epic instance for the same release. Stable product IDs remain the same across distinct Jira keys.
  • Preserve the full release-specific definition, scope, acceptance outcomes, item version and predecessor/successor links. Initial entries are INITIAL at v1; new entries are NEW at v1; unchanged entries keep their version and are UNCHANGED.
  • An UPDATED instance increments its version once and explains both what changed and the difference from the previous version. A new or updated Feature makes its owning Epic NEW or UPDATED as appropriate.
  • Do not duplicate or reopen Tasks because scope carries forward. Keep actual delivery allocation, Task history and evidence separate from release-specific scope instances. Carry-forward is not new work, approval or historical acceptance.

This is the agreed contract, not a claim that every existing Jira record already conforms. Preserve previous-release evidence rather than reconstructing it from today's mutable issue; report a missing instance or relationship on the owning work instead of creating a documentation mirror.

Owners and decisions​

MartynasP is the primary Scope owner; RootAtSkic is the backup owner, including escalation and cross-domain conflict. Scope owns product outcomes, priorities, release scope and acceptance outcomes. Hermes coordinates, prepares evidence and implements authorized work; it cannot substitute its recommendation for a human domain decision.

An Approved for Solution decision must identify the exact stable item, target gate, deciding owner, date, conditions and durable evidence. Epic approval does not approve its child Features. Conditional approval preserves unresolved conditions and risks; silence, a ticket assignment, CI success or implementation activity is not approval. Architecture starts solution work only after the applicable owner decision is recorded.

Agreed delivery lifecycle​

The agreed lifecycle and required-child contract distinguishes product design and delivery from Task execution:

Epic / Feature: IN_BACKLOG → IN_DESIGN → READY_FOR_DELIVERY → IN_DELIVERY → TO_BE_RELEASED → DONE
Task: IN_BACKLOG → READY_FOR_DELIVERY → IN_PROGRESS → TO_BE_RELEASED → DONE

CANCELLED is an exceptional terminal state, not an ordinary next step. The paths describe the operating model, not automatic permission to advance an issue.

StatusApplies toMeaning and boundary
IN_BACKLOGEpic, Feature, TaskThe item is retained but not actively designed or executed. Being recorded, assigned or prioritized does not mean work has started.
IN_DESIGNEpic, FeatureThe product item is actively scoped, decomposed or solutioned; no required implementation Task has started. Scope approval and Architecture readiness remain separate gates.
READY_FOR_DELIVERYEpic, Feature, TaskArchitecture, dependencies, implementation boundaries and verification steps are technically ready for the exact governed scope, with execution unstarted. Technical readiness alone is not Focus admission or implementation authorization.
IN_PROGRESSTaskThe exact Task is actively implemented or validated. A parent Epic or Feature uses IN_DELIVERY, not this Task execution status.
IN_DELIVERYEpic, FeatureRequired descendant implementation has started, or part of the required scope is already later in the delivery chain, while the complete product item has not reached TO_BE_RELEASED.
TO_BE_RELEASEDEpic, Feature, TaskThe complete required scope is implementation-complete and belongs to a release candidate, but release verification is not complete. This is not a synonym for merged, deployed or accepted.
DONEEpic, Feature, TaskThe complete required scope has passed its release boundary, or an explicitly non-releasable item has durable completion evidence. Completion must match the exact item's applicable outcome.
CANCELLEDEpic, Feature, TaskAn authorized decision has removed, rejected, abandoned or superseded the item. Cancellation is not completion and cannot stand in for DONE.

Status is not approval​

Delivery progress, approval gates, blocking, solution readiness, deployment health and acceptance are separate dimensions. Approved for Solution and Approved for Implementation are approval gates, not delivery statuses. READY_FOR_DELIVERY is an agreed conceptual lifecycle stage, not a new approval or a guaranteed native Jira status. Record technical readiness and exact Focus admission separately; neither a readiness label nor READY transport authorizes implementation. Reuse valid existing exact-item admission rather than requesting it again; if it is absent, the owning workflow must supply it before pickup.

Use the transitions available on the exact Jira issue type. The agreed lifecycle and readiness gates are not a claim that Jira enforces every rule or shares one status set across types. This process explanation does not change Jira workflows or issue states. Do not rename, map or move a native state merely to make it resemble this page. Record the agreed lifecycle basis, approval, readiness and blocker evidence on the existing issue when native configuration differs; route the mismatch to the workflow owner without inventing a transition or waiving the gate. See Planning in Jira for selection and execution guidance.

Readiness history and native representation​

The retained historical ways-of-working/scope.md introduced both readiness paths in commit 4129ec7. Commit 38a41b1 (7 September 2026, “make delivery readiness executable”) retained those paths and treated a ready Task as already admitted to Focus. That historical admission coupling is not permission to infer admission today: the later Option A handoff recorded technical readiness separately on AERS-424 while retaining native IN_BACKLOG, with separate exact Focus admission still required. It did not require repeating Scope approval.

The current Jira planning guide records that READY_FOR_DELIVERY was absent from the checked native workflows on 9 November 2026. Missing native configuration does not remove the conceptual stage. Keep the native issue state, conceptual lifecycle basis, technical readiness and admission evidence distinguishable on the existing issue. Do not mechanically map native IN_BACKLOG to conceptual readiness: only exact evidence establishes readiness. This reconciliation restores the full lifecycle without restoring obsolete automatic-admission semantics, changing Jira, restarting paused work or authorizing implementation, UI, UAT, deployment or release.

Transitions and evidence​

Every exact transition records the actor, authority, UTC date, previous and target state, conditions, and durable evidence for the exact item. Preserve its Jira key, stable identity and release context. Documentation activity, approval, CI success, merge state, deployment health or silence alone does not advance status.

TransitionRequired basis
Epic / Feature IN_BACKLOG → IN_DESIGNActive scoping, decomposition or solution work is evidenced for that item. Starting solution work still requires its separate applicable approval.
Epic / Feature to IN_DELIVERYRequired descendant implementation has started, as established by exact Task evidence and the ordered roll-up below; a parent approval or optional Task does not establish this.
Task IN_BACKLOG → READY_FOR_DELIVERYExact Architecture readiness evidence covers dependencies, implementation boundaries and verification steps; execution is unstarted. Record admission independently, not as an implication of technical readiness.
Epic / Feature to READY_FOR_DELIVERYThe complete non-empty required set satisfies the readiness roll-up below, or an explicit no-child exact-item readiness decision supplies the applicable evidence.
Task READY_FOR_DELIVERY → IN_PROGRESSExact implementation or validation has actually started under the owning delivery workflow, with separately evidenced exact Focus admission and applicable approval, dependency, readiness and capacity gates satisfied. If native Jira remains IN_BACKLOG, preserve this conceptual transition evidence separately rather than inventing a native readiness transition.
Task IN_PROGRESS → TO_BE_RELEASEDIts required implementation and validation are complete and its outcome belongs to a release candidate; release verification remains outstanding.
Task TO_BE_RELEASED → DONEThe applicable release boundary and completion condition are verified for the exact outcome, not inferred from a successful merge or healthy deployment.
Task IN_PROGRESS → DONEAllowed only when the outcome is explicitly non-releasable or the same evidence proves both implementation and release completion; record the reason.
Epic / Feature to TO_BE_RELEASED or DONEThe complete validated required-child set meets the ordered rule and the applicable release/completion boundary. A no-child item needs exact evidence instead of an empty-set roll-up.
Any item to CANCELLEDAn explicit authorized exact-item decision and the required descendant disposition; never a computed outcome or an inference from inactivity.

Moving the final required child can trigger the deterministic parent roll-up in the same canonical Jira reconciliation. Never fabricate a relationship, execution event or release evidence to complete that reconciliation. Keep approval, blocking, acceptance evidence, version allocation, deployment and release records separate even when they supply transition evidence.

Preserve append-only approval and lifecycle histories. An old approval-shaped status must remain historical gate evidence; establish a corrected delivery state through a new evidenced event rather than rewriting the old event. This page itself grants no approval and records no ticket transition.

Required-child roll-up​

Validate the complete required set at each boundary: Epic → required Features and Feature → required implementation Tasks. Relationships must resolve to the exact items and release context, without missing, duplicated or one-sided membership. Do not aggregate unrelated work or count a descendant twice. Required scope is distinct from optional, removed or superseded scope. Optional work does not automatically block completion and does not advance required-scope progress.

A cancelled child may be excluded only by an explicit authorized Scope decision that updates the parent's required set. Until that decision is recorded, retain it in the set: CANCELLED is never equivalent to DONE. Neither cancellation nor an empty set proves the parent outcome was delivered.

Evaluate the following rules in order, stopping at the first applicable result. Resolve exact cancellation first, then compute progress from the validated required set:

  1. CANCELLED is never derived. An explicit authorized decision for the parent is required; child cancellations cannot manufacture it.
  2. If the required-child set is non-empty and every required child is DONE, the parent is DONE, with its applicable parent-level completion evidence and release boundary satisfied.
  3. Otherwise, if every required child is either TO_BE_RELEASED or DONE and at least one is TO_BE_RELEASED, the parent is TO_BE_RELEASED, within the applicable release boundary.
  4. Otherwise, if the required-child set is non-empty, every required child is READY_FOR_DELIVERY, and the complete governed scope is architecture-ready with execution unstarted, the parent is READY_FOR_DELIVERY. This technical readiness roll-up does not derive Focus admission or authorize implementation.
  5. Otherwise, if any required descendant has entered active or later execution—Task IN_PROGRESS, or child IN_DELIVERY, TO_BE_RELEASED or DONE—the parent is IN_DELIVERY.
  6. Otherwise, an actively scoped, decomposed or solutioned product item is IN_DESIGN.
  7. Otherwise, the parent is IN_BACKLOG.

An item with no validated required children cannot derive READY_FOR_DELIVERY, TO_BE_RELEASED or DONE; require direct evidence for the exact item, its explicit completion condition and applicable release boundary. Do not treat a missing or invalid required set as an empty one. If required relationships or completion evidence are missing or contradictory, record the evidence gap and reconcile with the owning workflow rather than silently forcing a later state. A parent must never appear less advanced than an active required child.

Record Status basis separately: Required-child roll-up (status_source: DERIVED) for a computed parent; Exact item evidence (status_source: EXACT) for a Task transition or direct no-child decision. These provenance labels explain the result; they do not alter the uppercase status or assert that Jira has matching custom fields.

Examples of the rule, not current tickets:

  • All required Tasks READY_FOR_DELIVERY make a Feature technically READY_FOR_DELIVERY, not admitted or started. One ready Task plus one IN_BACKLOG does not satisfy readiness; use evidenced active design or backlog until the complete set is ready. A ready Task plus an IN_PROGRESS Task makes the Feature IN_DELIVERY.
  • One required Task DONE plus one IN_BACKLOG makes the Feature IN_DELIVERY, not DONE or TO_BE_RELEASED.
  • Required Tasks split between TO_BE_RELEASED and DONE make the Feature TO_BE_RELEASED at that release boundary.
  • Every required Feature must be DONE before its Epic can be DONE; an unfinished optional Feature does not automatically prevent that result.
  • A required cancelled child prevents the all-DONE rule until the authorized required-set decision resolves it; cancelling all children does not deliver or automatically cancel their parent.

Blocking, cancellation and dependencies​

BLOCKED is an orthogonal flag, never a lifecycle status. Keep the item's delivery status and record the blocker reason, owner/next action and evidence. Removing the blocker does not itself advance the lifecycle. A critical blocked required child may justify a parent blocked indicator; an optional or non-critical blocked child does not automatically block the parent.

Dependencies explain prerequisite work and execution order; they are not automatically required-child relationships or approval evidence. Preserve the owning workflow's dependency-aware pickup gates without turning a dependency link into a completion claim.

Cancelling a parent requires an explicit disposition for every descendant: cancel, supersede, exclude from required scope or re-parent under the authorized decision. Keep the decision and history; do not silently drop descendants, mark them done, or infer their cancellation from the parent's terminal state.

Release boundary and historical scope​

Evaluate progress against the release-specific Epic/Feature instance, its definition, acceptance outcomes, required set and evidence. TO_BE_RELEASED means its complete required scope belongs to a release candidate; DONE requires that scope's applicable verified release boundary, or explicit non-releasable completion evidence. Implementation completion, UAT acceptance, production promotion and release closure retain their separate owners and evidence.

Do not apply later scope or required-child changes retroactively to an earlier release instance. Preserve the earlier definition, decisions, Task history and accepted release evidence. An updated later instance has its own delta and outcome boundary; unchanged carry-forward is not a fresh acceptance decision. Do not duplicate or reopen Tasks to make cumulative release instances look like new execution. Reuse the verified Task lineage and actual delivery allocation without transferring evidence to a different outcome or unverified revision.

Handoff boundaries​

  • Scope → Architecture: hand over an approved Feature with its stable identity, parent Epic, release context, value, scope, acceptance outcomes, dependencies, risks, conditions and decision evidence. Architecture owns solution contracts, requirements, Task derivation and readiness; Tasks are not a prerequisite for Scope input readiness.
  • UI/UX: owns design decisions and design evidence; Scope approval does not approve the design or architecture.
  • Kanban / Delivery: own sequencing, dependency-aware pickup and implementation flow. Reuse exact-item admission evidence; neither an assignment nor board position creates approval. Attach review, exact-revision CI and verified development deployment evidence to the existing Jira work.
  • UAT / Releases: UAT records its verdict against the exact deployed revision; Releases owns authorized promotion and release closure. Implementation completion does not establish UAT acceptance or production release approval.

A handoff names the exact Jira work, source and destination owner, completed outcome, evidence, remaining conditions and next action. The destination checks its own entry gates and acknowledges or returns the handoff with the missing condition; a notification alone is not approval.

Continue with Planning in Jira or delivery ways of working. Follow the canonical CogArch links on the relevant Feature for architecture. Update current records in Jira, not on this overview.