Skip to content

Platform Narrative: CAS Orchestration Flows

Overview

The Continuous Architecture System (CAS) operates through structured, goal-oriented orchestration flows. Each flow represents a specific architectural or governance objective, executed via the cas CLI. This document provides a comprehensive reference for each flow, its purpose, and how to execute it.

Core Orchestration & Governance Flows

1. Orchestration Flow (orchestration-flow)

The primary pipeline for the CAS lifecycle. It transforms governance rules and architecture work into a system-wide evolution map and updated architectural intent.

  • Objective: Synchronize Intended Architecture with Actual Architecture.
  • Key Steps: Rules Context Loader → AEM Generator → Alignment Engine → AID Generator.
  • CLI Execution: 
    uv run cas run orchestration-flow --project <name> --provider <provider>

2. Governance Validator (governance-validator)

Automates the structural and integrity checks of the knowledge layer. This flow acts as the primary quality gate in CI/CD.

  • Objective: Ensure structural validity, traceability, and lifecycle compliance of all knowledge artifacts.
  • Key Steps: Governance Validator.
  • CLI Execution: 
    uv run cas run governance-validator --project <name>
    (Note: Can also be run via uv run cas governance validate)

3. Continuous Architecture Loop (continuous-architecture-loop)

Combines the main synchronization pipeline with immediate structural validation in a single execution flow.

  • Objective: Perform end-to-end synchronization and validate structural integrity.
  • Key Steps: Rules Context Loader → AEM Generator → Alignment Engine → AID Generator → Governance Validator.
  • CLI Execution: 
    uv run cas run continuous-architecture-loop --project <name> --provider <provider>

4. Baseline Discovery (discovery-flow)

Forensically maps the initial state of an existing project. This is the first flow executed when onboarding a new repository.

  • Objective: Establish the "Actual State" baseline.
  • Key Steps: Baseline Discovery → Rules Context Loader → Conversation to AW → AEM Generator → Alignment Engine → AID Generator.
  • CLI Execution: 
    uv run cas run discovery-flow --project <name> --provider <provider>

5. Steering Projection (steering-projection-flow)

Generates actionable steering proposals to resolve architectural drift identified by the alignment engine.

  • Objective: Propose corrections to keep the codebase aligned with architectural intent.
  • Key Steps: Steering Projection.
  • CLI Execution: 
    uv run cas run steering-projection-flow --project <name> --provider <provider>

6. Architecture Work Assessment (assessment-flow)

Assesses implementation coverage of architecture work items against active capabilities and recommends lifecycle state transitions.

  • Objective: Evaluate alignment evidence and suggest lifecycle status promotions.
  • Key Steps: Governance Context Builder → Architecture Work Assessment.
  • CLI Execution: 
    uv run cas run assessment-flow --project <name> --provider <provider>

Bootstrap & Ingestion Flows

7. Roadmap Bootstrap (roadmap-bootstrap-flow)

Initializes or synchronizes a project's product roadmap, initiatives, and items with GitHub Projects.

  • Objective: Load and validate roadmap definitions to build an operational backlog on GitHub.
  • Key Steps: Roadmap Bootstrap.
  • CLI Execution: 
    uv run cas run roadmap-bootstrap-flow --project <name>

8. Conversation to AW (conversation-to-aw)

Translates unstructured chat history or interview transcripts into structured architecture work artifacts.

  • Objective: Ingest discussions into the architecture work log.
  • Key Steps: Rules Context Loader → Conversation to AW.
  • CLI Execution: 
    uv run cas run conversation-to-aw --project <name> --provider <provider>

9. Discovery to AW (discovery-to-aw)

Converts baseline discovery reports and scan results into structured architecture work artifacts.

  • Objective: Ingest discovered artifacts into the architecture work log.
  • Key Steps: Rules Context Loader → Discovery to AW.
  • CLI Execution: 
    uv run cas run discovery-to-aw --project <name> --provider <provider>

10. Vision to AW (vision-to-aw)

Converts high-level strategy and vision documentation into structured architecture work.

  • Objective: Translate strategic goals into actionable architecture work.
  • Key Steps: Rules Context Loader → Vision to AW.
  • CLI Execution: 
    uv run cas run vision-to-aw --project <name> --provider <provider>

Architecture State Synthesis

11. Current Architecture State (current-architecture-state-generator)

Synthesizes the overall state of the system architecture from various input sources to maintain a comprehensive architectural viewpoint.

  • Objective: Generate a consolidated viewpoint of the current system state.
  • Key Steps: Rules Context Loader → Current Architecture State Generator.
  • CLI Execution: 
    uv run cas run current-architecture-state-generator --project <name> --provider <provider>

Intelligence & Pattern Evolution Flows

12. Signal to Pattern (signal-to-pattern-proposals)

Analyzes architectural signals and learnings to identify emerging concepts.

  • Objective: Discover new candidate patterns from operational evidence.
  • Key Steps: Rules Context Loader → Signal to Pattern Proposals.
  • CLI Execution: 
    uv run cas run signal-to-pattern-proposals --project <name> --provider <provider>

13. Pattern Scope Classifier (pattern-scope-classifier)

Determines the architectural scope (Global vs. Project) of proposed patterns.

  • Objective: Assign appropriate governance boundaries to emerging concepts.
  • Key Steps: Rules Context Loader → Pattern Scope Classifier.
  • CLI Execution: 
    uv run cas run pattern-scope-classifier --project <name> --provider <provider>

14. Pattern Promotion (pattern-promotion-workflow)

Evaluates scoped proposals against promotion criteria to generate formal recommendations.

  • Objective: Filter emerging concepts into "Recommended" candidates for institutionalization.
  • Key Steps: Rules Context Loader → Pattern Promotion Workflow.
  • CLI Execution: 
    uv run cas run pattern-promotion-workflow --project <name> --provider <provider>

15. Promotion Decision Capture (promotion-decision-capture)

Captures the human architect's decision on a system-recommended pattern promotion.

  • Objective: Provide the formal human-in-the-loop gate for pattern adoption.
  • Key Steps: Rules Context Loader → Promotion Decision Capture.
  • CLI Execution: 
    uv run cas run promotion-decision-capture --project <name> --provider <provider>

Technical Transformation Flows

16. Promotion to ADR (promotion-to-decision-records)

Transforms accepted promotion decisions into formal Architecture Decision Records (ADRs).

  • Objective: Formalize architectural decisions into the Single Source of Truth.
  • Key Steps: Rules Context Loader → Promotion to Decision Records.
  • CLI Execution: 
    uv run cas run promotion-to-decision-records --project <name> --provider <provider>

17. Approved ADR to Pattern (approved-adr-to-pattern)

Converts forum-approved ADRs into institutionalised Pattern artifacts.

  • Objective: Complete the lifecycle by establishing new architectural standards.
  • Key Steps: Rules Context Loader → Approved ADR to Pattern.
  • CLI Execution: 
    uv run cas run approved-adr-to-pattern --project <name> --provider <provider>

Platform Operations & Utility Commands

Beyond reasoning and sync flows, the cas CLI provides various commands for workspace setup, steering section operations, trace evaluations, and governance decisions.

1. Workspace Initialization (init-workspace)

Initializes or attaches to a CAS knowledge workspace, mapping a project to a shared local or remote storage directory. - Objective: Attach/bootstrap workspace paths and configure standard knowledge providers. - CLI Execution: 

uv run cas init-workspace --project <name> [--workspace-root <path>] [--provider <provider>] [--force]

2. Platform Bootstrap (bootstrap)

Sets up the initial CAS governance substrate, CI workflow directories, and configuration settings in a new repository. - Objective: Install the baseline CAS governance files and configurations. - CLI Execution: 

uv run cas bootstrap [target_directory] [--force] [--minimal] [--no-ci]

3. Governance Operations (governance)

Provides administrative operations for validating, merging, and transitioning the state of governed artifacts. - Actions: - Validate (validate): Runs structural and schema validation checks (alias for governance-validator flow). 

uv run cas governance validate --project <name> [--provider <provider>]
- Assess (assess): Evaluates implementation coverage of Architecture Work (alias for assessment-flow flow). 
uv run cas governance assess --project <name> [--provider <provider>]
- Conflict Resolver (resolve-conflicts): Discovers git conflict markers within the knowledge layer (.yaml, .json, .md) and automatically resolves them using the LLM-powered Agentic Merger. 
uv run cas governance resolve-conflicts --project <name> [--provider <provider>]
- Action Service (approve / reject / defer / reopen): Transitions the status of a specific governed artifact (promotion decisions, ADRs, exceptions, architecture work items) with a provided justification. 
uv run cas governance approve <artifact_id> --rationale <text> --project <name>

4. Steering Operations (steering)

Manages capability inventories and applies proposed steering projections to align the codebase. - Actions: - Validate (validate): Verifies that managed steering sections inside documents are intact and structurally valid. 

uv run cas steering validate [--managed-sections-only]
- Apply (apply): Parses and applies proposed capability change replacements (from frontmatter proposals) directly into target source files. 
uv run cas steering apply --projection <projection_id_or_path> [--dry-run]
- Bootstrap (bootstrap): Performs a one-time baseline git reference scan to bootstrap the Runtime Capability Inventory. 
uv run cas steering bootstrap --project <name> [--baseline-ref <hash>]

5. Governance Dashboard (dashboard)

Renders and prints a summary of the project's architectural compliance and health metrics in markdown or json formats. - Objective: Inspect the local compliance state of the project. - CLI Execution: 

uv run cas dashboard --project <name> [--format markdown|json]

6. Trace Evaluation (evaluate)

Runs LLM-powered quality evaluations on trace files generated by prior reasoning runs to score response quality and check rules alignment. - Objective: Run automated eval criteria against execution history logs. - CLI Execution: 

uv run cas evaluate <trace_id_prefix> --project <name> --provider <provider>

Operational Summary

  • Idempotency: All CAS flows are designed to be idempotent; running them multiple times against the same input will yield consistent, versioned artifacts.
  • Human-in-the-Loop: While flows automate the "Detect" and "Propose" stages, the "Decide" stage (Action Framework) remains an explicit human-driven gate.
  • Telemetry: Every execution generates a trace log in knowledge/runtime/traces/, enabling continuous evaluation of orchestration quality.