Add risk assessment system

Introduce a hierarchical risk assessment model with six entity types:

- Risk Assessment: top-level container scoped to an organization
- Risk Assessment Scope: sub-container for scoping threat modeling
  exercises within an assessment
- Risk Assessment Node: DFD elements typed as ENTITY, BOUNDARY,
  ASSET, or DATA within a scope
- Risk Assessment Process: directed data flows between two nodes
- Risk Assessment Threat: descriptive threats attached to a process
  with a free-text category (e.g. Confidentiality, Integrity)
- Risk Scenario: thin join linking a threat to a risk from the
  register, carrying only a name and description

Risk scoring (likelihood, impact, treatment) remains on the existing
Risk entity. Threats are purely descriptive. Risk Scenarios connect
the threat model to the risk register without duplicating scores.

Backend: migration with PG enum for node types, coredata structs,
service layer with full CRUD and validation, GraphQL schema with
18 mutations and paginated connections, authorization actions and
policies, and base_resolvers.go Node dispatch for all entity types.

Frontend: Risk Assessments list page with create dialog, detail page
showing scopes as cards with nodes/processes/threats tables, inline
create/edit/delete actions on all entities, and a Scenarios tab on
the Risk detail page linking threats to risks. Existing RiskGraph.ts
hook file removed in favor of colocated queries in page files.

E2E tests cover CRUD for all entity types, RBAC, and tenant
isolation.

Signed-off-by: Sacha Al Himdani <sacha@getprobo.com>

pkg/coredata/entity_type_reg.go

@@ -118,6 +118,12 @@ const (
 	CommonThirdPartyEntityType                     uint16 = 92
 	CommonThirdPartyDomainEntityType               uint16 = 93
 	CommonTrackerPatternEntityType                 uint16 = 94
+	RiskAssessmentEntityType                       uint16 = 95
+	RiskAssessmentNodeEntityType                   uint16 = 96
+	RiskAssessmentProcessEntityType                uint16 = 97
+	RiskAssessmentThreatEntityType                 uint16 = 98
+	RiskAssessmentScopeEntityType                  uint16 = 99
+	RiskAssessmentScenarioEntityType               uint16 = 100
 )
 
 func NewEntityFromID(id gid.GID) (any, bool) {
@@ -296,6 +302,18 @@ func NewEntityFromID(id gid.GID) (any, bool) {
 		return &CommonThirdPartyDomain{ID: id}, true
 	case CommonTrackerPatternEntityType:
 		return &CommonTrackerPattern{ID: id}, true
+	case RiskAssessmentEntityType:
+		return &RiskAssessment{ID: id}, true
+	case RiskAssessmentNodeEntityType:
+		return &RiskAssessmentNode{ID: id}, true
+	case RiskAssessmentProcessEntityType:
+		return &RiskAssessmentProcess{ID: id}, true
+	case RiskAssessmentThreatEntityType:
+		return &RiskAssessmentThreat{ID: id}, true
+	case RiskAssessmentScopeEntityType:
+		return &RiskAssessmentScope{ID: id}, true
+	case RiskAssessmentScenarioEntityType:
+		return &RiskAssessmentScenario{ID: id}, true
 	default:
 		return nil, false
 	}

pkg/coredata/migrations/20260421T140001Z.sql

@@ -0,0 +1,100 @@
+-- Copyright (c) 2025-2026 Probo Inc <hello@getprobo.com>.
+--
+-- Permission to use, copy, modify, and/or distribute this software for any
+-- purpose with or without fee is hereby granted, provided that the above
+-- copyright notice and this permission notice appear in all copies.
+--
+-- THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+-- REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+-- AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+-- INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+-- LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+-- OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+-- PERFORMANCE OF THIS SOFTWARE.
+
+CREATE TABLE risk_assessments (
+    id TEXT PRIMARY KEY,
+    tenant_id TEXT NOT NULL,
+    organization_id TEXT NOT NULL REFERENCES organizations(id) ON DELETE CASCADE,
+    name TEXT NOT NULL,
+    description TEXT,
+    created_at TIMESTAMP WITH TIME ZONE NOT NULL,
+    updated_at TIMESTAMP WITH TIME ZONE NOT NULL
+);
+
+CREATE TABLE risk_assessment_scopes (
+    id TEXT PRIMARY KEY,
+    tenant_id TEXT NOT NULL,
+    organization_id TEXT NOT NULL,
+    risk_assessment_id TEXT NOT NULL REFERENCES risk_assessments(id) ON DELETE CASCADE,
+    name TEXT NOT NULL,
+    created_at TIMESTAMP WITH TIME ZONE NOT NULL,
+    updated_at TIMESTAMP WITH TIME ZONE NOT NULL
+);
+
+CREATE TYPE risk_assessment_node_type AS ENUM ('ENTITY', 'BOUNDARY', 'ASSET', 'DATA');
+
+CREATE TABLE risk_assessment_nodes (
+    id TEXT PRIMARY KEY,
+    tenant_id TEXT NOT NULL,
+    organization_id TEXT NOT NULL,
+    risk_assessment_scope_id TEXT NOT NULL REFERENCES risk_assessment_scopes(id) ON DELETE CASCADE,
+    node_type risk_assessment_node_type NOT NULL,
+    name TEXT NOT NULL,
+    created_at TIMESTAMP WITH TIME ZONE NOT NULL,
+    updated_at TIMESTAMP WITH TIME ZONE NOT NULL,
+    CONSTRAINT risk_assessment_nodes_unique_name UNIQUE (risk_assessment_scope_id, name)
+);
+
+CREATE TABLE risk_assessment_processes (
+    id TEXT PRIMARY KEY,
+    tenant_id TEXT NOT NULL,
+    organization_id TEXT NOT NULL,
+    risk_assessment_scope_id TEXT NOT NULL REFERENCES risk_assessment_scopes(id) ON DELETE CASCADE,
+    source_node_id TEXT NOT NULL REFERENCES risk_assessment_nodes(id) ON DELETE CASCADE,
+    target_node_id TEXT NOT NULL REFERENCES risk_assessment_nodes(id) ON DELETE CASCADE,
+    name TEXT NOT NULL,
+    created_at TIMESTAMP WITH TIME ZONE NOT NULL,
+    updated_at TIMESTAMP WITH TIME ZONE NOT NULL,
+    CONSTRAINT risk_assessment_processes_unique_name UNIQUE (risk_assessment_scope_id, name)
+);
+
+CREATE TABLE risk_assessment_threats (
+    id TEXT PRIMARY KEY,
+    tenant_id TEXT NOT NULL,
+    organization_id TEXT NOT NULL,
+    risk_assessment_scope_id TEXT NOT NULL REFERENCES risk_assessment_scopes(id) ON DELETE CASCADE,
+    process_id TEXT NOT NULL REFERENCES risk_assessment_processes(id) ON DELETE CASCADE,
+    name TEXT NOT NULL,
+    category TEXT NOT NULL,
+    created_at TIMESTAMP WITH TIME ZONE NOT NULL,
+    updated_at TIMESTAMP WITH TIME ZONE NOT NULL,
+    CONSTRAINT risk_assessment_threats_unique_name UNIQUE (risk_assessment_scope_id, name)
+);
+
+CREATE TABLE risk_assessment_scenarios (
+    id TEXT PRIMARY KEY,
+    tenant_id TEXT NOT NULL,
+    organization_id TEXT NOT NULL,
+    risk_assessment_scope_id TEXT NOT NULL REFERENCES risk_assessment_scopes(id) ON DELETE CASCADE,
+    name TEXT NOT NULL,
+    description TEXT,
+    created_at TIMESTAMP WITH TIME ZONE NOT NULL,
+    updated_at TIMESTAMP WITH TIME ZONE NOT NULL
+);
+
+CREATE TABLE risk_assessment_scenario_threats (
+    tenant_id TEXT NOT NULL,
+    risk_assessment_scenario_id TEXT NOT NULL REFERENCES risk_assessment_scenarios(id) ON DELETE CASCADE,
+    risk_assessment_threat_id TEXT NOT NULL REFERENCES risk_assessment_threats(id) ON DELETE CASCADE,
+    created_at TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT NOW(),
+    PRIMARY KEY (risk_assessment_scenario_id, risk_assessment_threat_id)
+);
+
+CREATE TABLE risk_assessment_scenario_risks (
+    tenant_id TEXT NOT NULL,
+    risk_assessment_scenario_id TEXT NOT NULL REFERENCES risk_assessment_scenarios(id) ON DELETE CASCADE,
+    risk_id TEXT NOT NULL REFERENCES risks(id) ON DELETE CASCADE,
+    created_at TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT NOW(),
+    PRIMARY KEY (risk_assessment_scenario_id, risk_id)
+);

pkg/coredata/risk_assessment.go

@@ -0,0 +1,254 @@
+// Copyright (c) 2026 Probo Inc <hello@getprobo.com>.
+//
+// Permission to use, copy, modify, and/or distribute this software for any
+// purpose with or without fee is hereby granted, provided that the above
+// copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+// REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+// AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+// INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+// LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+// OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+package coredata
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"maps"
+	"time"
+
+	"github.com/jackc/pgx/v5"
+	"github.com/jackc/pgx/v5/pgconn"
+	"go.gearno.de/kit/pg"
+	"go.probo.inc/probo/pkg/gid"
+	"go.probo.inc/probo/pkg/page"
+)
+
+type (
+	RiskAssessment struct {
+		ID             gid.GID   `db:"id"`
+		OrganizationID gid.GID   `db:"organization_id"`
+		Name           string    `db:"name"`
+		Description    *string   `db:"description"`
+		CreatedAt      time.Time `db:"created_at"`
+		UpdatedAt      time.Time `db:"updated_at"`
+	}
+
+	RiskAssessments []*RiskAssessment
+)
+
+func (ra *RiskAssessment) CursorKey(orderBy RiskAssessmentOrderField) page.CursorKey {
+	switch orderBy {
+	case RiskAssessmentOrderFieldCreatedAt:
+		return page.CursorKey{ID: ra.ID, Value: ra.CreatedAt}
+	case RiskAssessmentOrderFieldName:
+		return page.CursorKey{ID: ra.ID, Value: ra.Name}
+	}
+
+	panic(fmt.Sprintf("unsupported order by: %s", orderBy))
+}
+
+func (ra *RiskAssessment) AuthorizationAttributes(ctx context.Context, conn pg.Querier) (map[string]string, error) {
+	q := `SELECT organization_id FROM risk_assessments WHERE id = $1 LIMIT 1;`
+
+	var organizationID gid.GID
+	if err := conn.QueryRow(ctx, q, ra.ID).Scan(&organizationID); err != nil {
+		if errors.Is(err, pgx.ErrNoRows) {
+			return nil, ErrResourceNotFound
+		}
+		return nil, fmt.Errorf("cannot query risk assessment authorization attributes: %w", err)
+	}
+
+	return map[string]string{"organization_id": organizationID.String()}, nil
+}
+
+func (ra *RiskAssessments) CountByOrganizationID(
+	ctx context.Context,
+	conn pg.Querier,
+	scope Scoper,
+	organizationID gid.GID,
+) (int, error) {
+	q := `
+SELECT COUNT(id)
+FROM risk_assessments
+WHERE %s
+	AND organization_id = @organization_id
+`
+	q = fmt.Sprintf(q, scope.SQLFragment())
+
+	args := pgx.NamedArgs{"organization_id": organizationID}
+	maps.Copy(args, scope.SQLArguments())
+
+	var count int
+	if err := conn.QueryRow(ctx, q, args).Scan(&count); err != nil {
+		return 0, fmt.Errorf("cannot count risk assessments: %w", err)
+	}
+
+	return count, nil
+}
+
+func (ra *RiskAssessments) LoadByOrganizationID(
+	ctx context.Context,
+	conn pg.Querier,
+	scope Scoper,
+	organizationID gid.GID,
+	cursor *page.Cursor[RiskAssessmentOrderField],
+) error {
+	q := `
+SELECT id, organization_id, name, description, created_at, updated_at
+FROM risk_assessments
+WHERE %s
+	AND organization_id = @organization_id
+	AND %s
+`
+	q = fmt.Sprintf(q, scope.SQLFragment(), cursor.SQLFragment())
+
+	args := pgx.NamedArgs{"organization_id": organizationID}
+	maps.Copy(args, scope.SQLArguments())
+	maps.Copy(args, cursor.SQLArguments())
+
+	rows, err := conn.Query(ctx, q, args)
+	if err != nil {
+		return fmt.Errorf("cannot query risk assessments: %w", err)
+	}
+
+	results, err := pgx.CollectRows(rows, pgx.RowToAddrOfStructByName[RiskAssessment])
+	if err != nil {
+		return fmt.Errorf("cannot collect risk assessments: %w", err)
+	}
+
+	*ra = results
+
+	return nil
+}
+
+func (ra *RiskAssessment) LoadByID(
+	ctx context.Context,
+	conn pg.Querier,
+	scope Scoper,
+	id gid.GID,
+) error {
+	q := `
+SELECT
+	id,
+	organization_id,
+	name,
+	description,
+	created_at,
+	updated_at
+FROM risk_assessments
+WHERE %s
+	AND id = @id
+LIMIT 1;
+`
+	q = fmt.Sprintf(q, scope.SQLFragment())
+
+	args := pgx.StrictNamedArgs{"id": id}
+	maps.Copy(args, scope.SQLArguments())
+
+	rows, err := conn.Query(ctx, q, args)
+	if err != nil {
+		return fmt.Errorf("cannot query risk assessment: %w", err)
+	}
+
+	result, err := pgx.CollectExactlyOneRow(rows, pgx.RowToStructByName[RiskAssessment])
+	if err != nil {
+		if errors.Is(err, pgx.ErrNoRows) {
+			return ErrResourceNotFound
+		}
+
+		return fmt.Errorf("cannot collect risk assessment: %w", err)
+	}
+
+	*ra = result
+
+	return nil
+}
+
+func (ra *RiskAssessment) Insert(
+	ctx context.Context,
+	conn pg.Tx,
+	scope Scoper,
+) error {
+	q := `
+INSERT INTO risk_assessments (id, tenant_id, organization_id, name, description, created_at, updated_at)
+VALUES (@id, @tenant_id, @organization_id, @name, @description, @created_at, @updated_at)
+`
+
+	args := pgx.StrictNamedArgs{
+		"id":              ra.ID,
+		"tenant_id":       scope.GetTenantID(),
+		"organization_id": ra.OrganizationID,
+		"name":            ra.Name,
+		"description":     ra.Description,
+		"created_at":      ra.CreatedAt,
+		"updated_at":      ra.UpdatedAt,
+	}
+
+	_, err := conn.Exec(ctx, q, args)
+	if err != nil {
+		if pgErr, ok := errors.AsType[*pgconn.PgError](err); ok && pgErr.Code == "23505" {
+			return ErrResourceAlreadyExists
+		}
+		return fmt.Errorf("cannot insert risk assessment: %w", err)
+	}
+	return nil
+}
+
+func (ra *RiskAssessment) Update(
+	ctx context.Context,
+	conn pg.Tx,
+	scope Scoper,
+) error {
+	q := `
+UPDATE risk_assessments
+SET
+	name = @name,
+	description = @description,
+	updated_at = @updated_at
+WHERE %s
+	AND id = @id
+`
+	q = fmt.Sprintf(q, scope.SQLFragment())
+
+	args := pgx.StrictNamedArgs{
+		"id":          ra.ID,
+		"name":        ra.Name,
+		"description": ra.Description,
+		"updated_at":  ra.UpdatedAt,
+	}
+	maps.Copy(args, scope.SQLArguments())
+
+	result, err := conn.Exec(ctx, q, args)
+	if err != nil {
+		return fmt.Errorf("cannot update risk assessment: %w", err)
+	}
+
+	if result.RowsAffected() == 0 {
+		return ErrResourceNotFound
+	}
+
+	return nil
+}
+
+func (ra *RiskAssessment) Delete(
+	ctx context.Context,
+	conn pg.Tx,
+	scope Scoper,
+	id gid.GID,
+) error {
+	q := `
+DELETE FROM risk_assessments WHERE %s AND id = @id
+`
+	q = fmt.Sprintf(q, scope.SQLFragment())
+
+	args := pgx.StrictNamedArgs{"id": id}
+	maps.Copy(args, scope.SQLArguments())
+
+	_, err := conn.Exec(ctx, q, args)
+	return err
+}

pkg/coredata/risk_assessment_node.go

@@ -0,0 +1,257 @@
+// Copyright (c) 2026 Probo Inc <hello@getprobo.com>.
+//
+// Permission to use, copy, modify, and/or distribute this software for any
+// purpose with or without fee is hereby granted, provided that the above
+// copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+// REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+// AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+// INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+// LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+// OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+package coredata
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"maps"
+	"time"
+
+	"github.com/jackc/pgx/v5"
+	"github.com/jackc/pgx/v5/pgconn"
+	"go.gearno.de/kit/pg"
+	"go.probo.inc/probo/pkg/gid"
+	"go.probo.inc/probo/pkg/page"
+)
+
+type (
+	RiskAssessmentNode struct {
+		ID                    gid.GID                `db:"id"`
+		OrganizationID        gid.GID                `db:"organization_id"`
+		RiskAssessmentScopeID gid.GID                `db:"risk_assessment_scope_id"`
+		NodeType              RiskAssessmentNodeType `db:"node_type"`
+		Name                  string                 `db:"name"`
+		CreatedAt             time.Time              `db:"created_at"`
+		UpdatedAt             time.Time              `db:"updated_at"`
+	}
+
+	RiskAssessmentNodes []*RiskAssessmentNode
+)
+
+func (n *RiskAssessmentNode) CursorKey(orderBy RiskAssessmentNodeOrderField) page.CursorKey {
+	switch orderBy {
+	case RiskAssessmentNodeOrderFieldCreatedAt:
+		return page.CursorKey{ID: n.ID, Value: n.CreatedAt}
+	case RiskAssessmentNodeOrderFieldName:
+		return page.CursorKey{ID: n.ID, Value: n.Name}
+	}
+	panic(fmt.Sprintf("unsupported order by: %s", orderBy))
+}
+
+func (n *RiskAssessmentNode) AuthorizationAttributes(ctx context.Context, conn pg.Querier) (map[string]string, error) {
+	q := `SELECT organization_id FROM risk_assessment_nodes WHERE id = $1 LIMIT 1;`
+
+	var organizationID gid.GID
+	if err := conn.QueryRow(ctx, q, n.ID).Scan(&organizationID); err != nil {
+		if errors.Is(err, pgx.ErrNoRows) {
+			return nil, ErrResourceNotFound
+		}
+		return nil, fmt.Errorf("cannot query risk assessment node authorization attributes: %w", err)
+	}
+
+	return map[string]string{"organization_id": organizationID.String()}, nil
+}
+
+func (ns *RiskAssessmentNodes) LoadByRiskAssessmentScopeID(
+	ctx context.Context,
+	conn pg.Querier,
+	scope Scoper,
+	riskAssessmentScopeID gid.GID,
+	cursor *page.Cursor[RiskAssessmentNodeOrderField],
+) error {
+	q := `
+SELECT
+	id,
+	organization_id,
+	risk_assessment_scope_id,
+	node_type,
+	name,
+	created_at,
+	updated_at
+FROM
+	risk_assessment_nodes
+WHERE
+	%s
+	AND risk_assessment_scope_id = @risk_assessment_scope_id
+	AND %s
+`
+	q = fmt.Sprintf(q, scope.SQLFragment(), cursor.SQLFragment())
+	args := pgx.NamedArgs{"risk_assessment_scope_id": riskAssessmentScopeID}
+	maps.Copy(args, scope.SQLArguments())
+	maps.Copy(args, cursor.SQLArguments())
+
+	rows, err := conn.Query(ctx, q, args)
+	if err != nil {
+		return fmt.Errorf("cannot query risk assessment nodes: %w", err)
+	}
+	results, err := pgx.CollectRows(rows, pgx.RowToAddrOfStructByName[RiskAssessmentNode])
+	if err != nil {
+		return fmt.Errorf("cannot collect risk assessment nodes: %w", err)
+	}
+	*ns = results
+	return nil
+}
+
+func (ns *RiskAssessmentNodes) CountByRiskAssessmentScopeID(
+	ctx context.Context,
+	conn pg.Querier,
+	scope Scoper,
+	riskAssessmentScopeID gid.GID,
+) (int, error) {
+	q := `
+SELECT
+	COUNT(id)
+FROM
+	risk_assessment_nodes
+WHERE
+	%s
+	AND risk_assessment_scope_id = @risk_assessment_scope_id
+`
+
+	q = fmt.Sprintf(q, scope.SQLFragment())
+	args := pgx.NamedArgs{"risk_assessment_scope_id": riskAssessmentScopeID}
+	maps.Copy(args, scope.SQLArguments())
+
+	var count int
+	if err := conn.QueryRow(ctx, q, args).Scan(&count); err != nil {
+		return 0, fmt.Errorf("cannot count risk assessment nodes: %w", err)
+	}
+	return count, nil
+}
+
+func (n *RiskAssessmentNode) LoadByID(ctx context.Context, conn pg.Querier, scope Scoper, id gid.GID) error {
+	q := `
+SELECT
+	id,
+	organization_id,
+	risk_assessment_scope_id,
+	node_type,
+	name,
+	created_at,
+	updated_at
+FROM
+	risk_assessment_nodes
+WHERE
+	%s
+	AND id = @id
+LIMIT 1;
+`
+	q = fmt.Sprintf(q, scope.SQLFragment())
+	args := pgx.StrictNamedArgs{"id": id}
+	maps.Copy(args, scope.SQLArguments())
+
+	rows, err := conn.Query(ctx, q, args)
+	if err != nil {
+		return fmt.Errorf("cannot query risk assessment node: %w", err)
+	}
+	result, err := pgx.CollectExactlyOneRow(rows, pgx.RowToStructByName[RiskAssessmentNode])
+	if err != nil {
+		if errors.Is(err, pgx.ErrNoRows) {
+			return ErrResourceNotFound
+		}
+		return fmt.Errorf("cannot collect risk assessment node: %w", err)
+	}
+	*n = result
+	return nil
+}
+
+func (n *RiskAssessmentNode) Insert(ctx context.Context, conn pg.Tx, scope Scoper) error {
+	q := `
+INSERT INTO risk_assessment_nodes (
+	id,
+	tenant_id,
+	organization_id,
+	risk_assessment_scope_id,
+	node_type,
+	name,
+	created_at,
+	updated_at
+) VALUES (
+	@id,
+	@tenant_id,
+	@organization_id,
+	@risk_assessment_scope_id,
+	@node_type,
+	@name,
+	@created_at,
+	@updated_at
+)
+`
+	args := pgx.StrictNamedArgs{
+		"id":                       n.ID,
+		"tenant_id":                scope.GetTenantID(),
+		"organization_id":          n.OrganizationID,
+		"risk_assessment_scope_id": n.RiskAssessmentScopeID,
+		"node_type":                n.NodeType,
+		"name":                     n.Name,
+		"created_at":               n.CreatedAt,
+		"updated_at":               n.UpdatedAt,
+	}
+	_, err := conn.Exec(ctx, q, args)
+	if err != nil {
+		if pgErr, ok := errors.AsType[*pgconn.PgError](err); ok && pgErr.Code == "23505" {
+			return ErrResourceAlreadyExists
+		}
+		return fmt.Errorf("cannot insert risk assessment node: %w", err)
+	}
+	return nil
+}
+
+func (n *RiskAssessmentNode) Update(ctx context.Context, conn pg.Tx, scope Scoper) error {
+	q := `
+UPDATE risk_assessment_nodes
+SET
+	node_type = @node_type,
+	name = @name,
+	updated_at = @updated_at
+WHERE
+	%s
+	AND id = @id
+`
+	q = fmt.Sprintf(q, scope.SQLFragment())
+	args := pgx.StrictNamedArgs{
+		"id":         n.ID,
+		"node_type":  n.NodeType,
+		"name":       n.Name,
+		"updated_at": n.UpdatedAt,
+	}
+	maps.Copy(args, scope.SQLArguments())
+
+	result, err := conn.Exec(ctx, q, args)
+	if err != nil {
+		return fmt.Errorf("cannot update risk assessment node: %w", err)
+	}
+	if result.RowsAffected() == 0 {
+		return ErrResourceNotFound
+	}
+	return nil
+}
+
+func (n *RiskAssessmentNode) Delete(ctx context.Context, conn pg.Tx, scope Scoper, id gid.GID) error {
+	q := `
+DELETE FROM risk_assessment_nodes
+WHERE
+	%s
+	AND id = @id
+`
+	q = fmt.Sprintf(q, scope.SQLFragment())
+	args := pgx.StrictNamedArgs{"id": id}
+	maps.Copy(args, scope.SQLArguments())
+
+	_, err := conn.Exec(ctx, q, args)
+	return err
+}

pkg/coredata/risk_assessment_node_order_field.go

@@ -0,0 +1,34 @@
+// Copyright (c) 2026 Probo Inc <hello@getprobo.com>.
+//
+// Permission to use, copy, modify, and/or distribute this software for any
+// purpose with or without fee is hereby granted, provided that the above
+// copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+// REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+// AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+// INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+// LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+// OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+package coredata
+
+type RiskAssessmentNodeOrderField string
+
+const (
+	RiskAssessmentNodeOrderFieldCreatedAt RiskAssessmentNodeOrderField = "CREATED_AT"
+	RiskAssessmentNodeOrderFieldName      RiskAssessmentNodeOrderField = "NAME"
+)
+
+func (p RiskAssessmentNodeOrderField) Column() string { return string(p) }
+func (p RiskAssessmentNodeOrderField) String() string { return string(p) }
+
+func (p RiskAssessmentNodeOrderField) MarshalText() ([]byte, error) {
+	return []byte(p.String()), nil
+}
+
+func (p *RiskAssessmentNodeOrderField) UnmarshalText(text []byte) error {
+	*p = RiskAssessmentNodeOrderField(text)
+	return nil
+}

pkg/coredata/risk_assessment_node_type.go

@@ -0,0 +1,78 @@
+// Copyright (c) 2026 Probo Inc <hello@getprobo.com>.
+//
+// Permission to use, copy, modify, and/or distribute this software for any
+// purpose with or without fee is hereby granted, provided that the above
+// copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+// REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+// AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+// INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+// LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+// OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+package coredata
+
+import (
+	"database/sql/driver"
+	"fmt"
+)
+
+type RiskAssessmentNodeType string
+
+const (
+	RiskAssessmentNodeTypeEntity   RiskAssessmentNodeType = "ENTITY"
+	RiskAssessmentNodeTypeBoundary RiskAssessmentNodeType = "BOUNDARY"
+	RiskAssessmentNodeTypeAsset    RiskAssessmentNodeType = "ASSET"
+	RiskAssessmentNodeTypeData     RiskAssessmentNodeType = "DATA"
+)
+
+func RiskAssessmentNodeTypes() []RiskAssessmentNodeType {
+	return []RiskAssessmentNodeType{
+		RiskAssessmentNodeTypeEntity,
+		RiskAssessmentNodeTypeBoundary,
+		RiskAssessmentNodeTypeAsset,
+		RiskAssessmentNodeTypeData,
+	}
+}
+
+func (t RiskAssessmentNodeType) MarshalText() ([]byte, error) {
+	return []byte(t.String()), nil
+}
+
+func (t *RiskAssessmentNodeType) UnmarshalText(data []byte) error {
+	val := string(data)
+
+	switch val {
+	case RiskAssessmentNodeTypeEntity.String():
+		*t = RiskAssessmentNodeTypeEntity
+	case RiskAssessmentNodeTypeBoundary.String():
+		*t = RiskAssessmentNodeTypeBoundary
+	case RiskAssessmentNodeTypeAsset.String():
+		*t = RiskAssessmentNodeTypeAsset
+	case RiskAssessmentNodeTypeData.String():
+		*t = RiskAssessmentNodeTypeData
+	default:
+		return fmt.Errorf("invalid RiskAssessmentNodeType value: %q", val)
+	}
+
+	return nil
+}
+
+func (t RiskAssessmentNodeType) String() string {
+	return string(t)
+}
+
+func (t *RiskAssessmentNodeType) Scan(value any) error {
+	val, ok := value.(string)
+	if !ok {
+		return fmt.Errorf("invalid scan source for RiskAssessmentNodeType, expected string got %T", value)
+	}
+
+	return t.UnmarshalText([]byte(val))
+}
+
+func (t RiskAssessmentNodeType) Value() (driver.Value, error) {
+	return t.String(), nil
+}

pkg/coredata/risk_assessment_order_field.go

@@ -0,0 +1,39 @@
+// Copyright (c) 2026 Probo Inc <hello@getprobo.com>.
+//
+// Permission to use, copy, modify, and/or distribute this software for any
+// purpose with or without fee is hereby granted, provided that the above
+// copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+// REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+// AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+// INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+// LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+// OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+package coredata
+
+type RiskAssessmentOrderField string
+
+const (
+	RiskAssessmentOrderFieldCreatedAt RiskAssessmentOrderField = "CREATED_AT"
+	RiskAssessmentOrderFieldName      RiskAssessmentOrderField = "NAME"
+)
+
+func (p RiskAssessmentOrderField) Column() string {
+	return string(p)
+}
+
+func (p RiskAssessmentOrderField) String() string {
+	return string(p)
+}
+
+func (p RiskAssessmentOrderField) MarshalText() ([]byte, error) {
+	return []byte(p.String()), nil
+}
+
+func (p *RiskAssessmentOrderField) UnmarshalText(text []byte) error {
+	*p = RiskAssessmentOrderField(text)
+	return nil
+}

pkg/coredata/risk_assessment_process.go

@@ -0,0 +1,262 @@
+// Copyright (c) 2026 Probo Inc <hello@getprobo.com>.
+//
+// Permission to use, copy, modify, and/or distribute this software for any
+// purpose with or without fee is hereby granted, provided that the above
+// copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+// REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+// AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+// INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+// LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+// OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+package coredata
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"maps"
+	"time"
+
+	"github.com/jackc/pgx/v5"
+	"github.com/jackc/pgx/v5/pgconn"
+	"go.gearno.de/kit/pg"
+	"go.probo.inc/probo/pkg/gid"
+	"go.probo.inc/probo/pkg/page"
+)
+
+type (
+	RiskAssessmentProcess struct {
+		ID                    gid.GID   `db:"id"`
+		OrganizationID        gid.GID   `db:"organization_id"`
+		RiskAssessmentScopeID gid.GID   `db:"risk_assessment_scope_id"`
+		SourceNodeID          gid.GID   `db:"source_node_id"`
+		TargetNodeID          gid.GID   `db:"target_node_id"`
+		Name                  string    `db:"name"`
+		CreatedAt             time.Time `db:"created_at"`
+		UpdatedAt             time.Time `db:"updated_at"`
+	}
+
+	RiskAssessmentProcesses []*RiskAssessmentProcess
+)
+
+func (p *RiskAssessmentProcess) CursorKey(orderBy RiskAssessmentProcessOrderField) page.CursorKey {
+	switch orderBy {
+	case RiskAssessmentProcessOrderFieldCreatedAt:
+		return page.CursorKey{ID: p.ID, Value: p.CreatedAt}
+	case RiskAssessmentProcessOrderFieldName:
+		return page.CursorKey{ID: p.ID, Value: p.Name}
+	}
+	panic(fmt.Sprintf("unsupported order by: %s", orderBy))
+}
+
+func (p *RiskAssessmentProcess) AuthorizationAttributes(ctx context.Context, conn pg.Querier) (map[string]string, error) {
+	q := `SELECT organization_id FROM risk_assessment_processes WHERE id = $1 LIMIT 1;`
+
+	var organizationID gid.GID
+	if err := conn.QueryRow(ctx, q, p.ID).Scan(&organizationID); err != nil {
+		if errors.Is(err, pgx.ErrNoRows) {
+			return nil, ErrResourceNotFound
+		}
+		return nil, fmt.Errorf("cannot query risk assessment process authorization attributes: %w", err)
+	}
+
+	return map[string]string{"organization_id": organizationID.String()}, nil
+}
+
+func (ps *RiskAssessmentProcesses) LoadByRiskAssessmentScopeID(
+	ctx context.Context,
+	conn pg.Querier,
+	scope Scoper,
+	riskAssessmentScopeID gid.GID,
+	cursor *page.Cursor[RiskAssessmentProcessOrderField],
+) error {
+	q := `
+SELECT
+	id,
+	organization_id,
+	risk_assessment_scope_id,
+	source_node_id,
+	target_node_id,
+	name,
+	created_at,
+	updated_at
+FROM
+	risk_assessment_processes
+WHERE
+	%s
+	AND risk_assessment_scope_id = @risk_assessment_scope_id
+	AND %s
+`
+	q = fmt.Sprintf(q, scope.SQLFragment(), cursor.SQLFragment())
+	args := pgx.NamedArgs{"risk_assessment_scope_id": riskAssessmentScopeID}
+	maps.Copy(args, scope.SQLArguments())
+	maps.Copy(args, cursor.SQLArguments())
+
+	rows, err := conn.Query(ctx, q, args)
+	if err != nil {
+		return fmt.Errorf("cannot query risk assessment processes: %w", err)
+	}
+	results, err := pgx.CollectRows(rows, pgx.RowToAddrOfStructByName[RiskAssessmentProcess])
+	if err != nil {
+		return fmt.Errorf("cannot collect risk assessment processes: %w", err)
+	}
+	*ps = results
+	return nil
+}
+
+func (ps *RiskAssessmentProcesses) CountByRiskAssessmentScopeID(
+	ctx context.Context,
+	conn pg.Querier,
+	scope Scoper,
+	riskAssessmentScopeID gid.GID,
+) (int, error) {
+	q := `
+SELECT
+	COUNT(id)
+FROM
+	risk_assessment_processes
+WHERE
+	%s
+	AND risk_assessment_scope_id = @risk_assessment_scope_id
+`
+
+	q = fmt.Sprintf(q, scope.SQLFragment())
+	args := pgx.NamedArgs{"risk_assessment_scope_id": riskAssessmentScopeID}
+	maps.Copy(args, scope.SQLArguments())
+
+	var count int
+	if err := conn.QueryRow(ctx, q, args).Scan(&count); err != nil {
+		return 0, fmt.Errorf("cannot count risk assessment processes: %w", err)
+	}
+	return count, nil
+}
+
+func (p *RiskAssessmentProcess) LoadByID(ctx context.Context, conn pg.Querier, scope Scoper, id gid.GID) error {
+	q := `
+SELECT
+	id,
+	organization_id,
+	risk_assessment_scope_id,
+	source_node_id,
+	target_node_id,
+	name,
+	created_at,
+	updated_at
+FROM
+	risk_assessment_processes
+WHERE
+	%s
+	AND id = @id
+LIMIT 1;
+`
+	q = fmt.Sprintf(q, scope.SQLFragment())
+	args := pgx.StrictNamedArgs{"id": id}
+	maps.Copy(args, scope.SQLArguments())
+	rows, err := conn.Query(ctx, q, args)
+	if err != nil {
+		return fmt.Errorf("cannot query risk assessment process: %w", err)
+	}
+	result, err := pgx.CollectExactlyOneRow(rows, pgx.RowToStructByName[RiskAssessmentProcess])
+	if err != nil {
+		if errors.Is(err, pgx.ErrNoRows) {
+			return ErrResourceNotFound
+		}
+		return fmt.Errorf("cannot collect risk assessment process: %w", err)
+	}
+	*p = result
+	return nil
+}
+
+func (p *RiskAssessmentProcess) Insert(ctx context.Context, conn pg.Tx, scope Scoper) error {
+	q := `
+INSERT INTO risk_assessment_processes (
+	id,
+	tenant_id,
+	organization_id,
+	risk_assessment_scope_id,
+	source_node_id,
+	target_node_id,
+	name,
+	created_at,
+	updated_at
+) VALUES (
+	@id,
+	@tenant_id,
+	@organization_id,
+	@risk_assessment_scope_id,
+	@source_node_id,
+	@target_node_id,
+	@name,
+	@created_at,
+	@updated_at
+)
+`
+	args := pgx.StrictNamedArgs{
+		"id":                       p.ID,
+		"tenant_id":                scope.GetTenantID(),
+		"organization_id":          p.OrganizationID,
+		"risk_assessment_scope_id": p.RiskAssessmentScopeID,
+		"source_node_id":           p.SourceNodeID,
+		"target_node_id":           p.TargetNodeID,
+		"name":                     p.Name,
+		"created_at":               p.CreatedAt,
+		"updated_at":               p.UpdatedAt,
+	}
+	_, err := conn.Exec(ctx, q, args)
+	if err != nil {
+		if pgErr, ok := errors.AsType[*pgconn.PgError](err); ok && pgErr.Code == "23505" {
+			return ErrResourceAlreadyExists
+		}
+		return fmt.Errorf("cannot insert risk assessment process: %w", err)
+	}
+	return nil
+}
+
+func (p *RiskAssessmentProcess) Update(ctx context.Context, conn pg.Tx, scope Scoper) error {
+	q := `
+UPDATE risk_assessment_processes
+SET
+	source_node_id = @source_node_id,
+	target_node_id = @target_node_id,
+	name = @name,
+	updated_at = @updated_at
+WHERE
+	%s
+	AND id = @id
+`
+	q = fmt.Sprintf(q, scope.SQLFragment())
+	args := pgx.StrictNamedArgs{
+		"id":             p.ID,
+		"source_node_id": p.SourceNodeID,
+		"target_node_id": p.TargetNodeID,
+		"name":           p.Name,
+		"updated_at":     p.UpdatedAt,
+	}
+	maps.Copy(args, scope.SQLArguments())
+	result, err := conn.Exec(ctx, q, args)
+	if err != nil {
+		return fmt.Errorf("cannot update risk assessment process: %w", err)
+	}
+	if result.RowsAffected() == 0 {
+		return ErrResourceNotFound
+	}
+	return nil
+}
+
+func (p *RiskAssessmentProcess) Delete(ctx context.Context, conn pg.Tx, scope Scoper, id gid.GID) error {
+	q := `
+DELETE FROM risk_assessment_processes
+WHERE
+	%s
+	AND id = @id
+`
+	q = fmt.Sprintf(q, scope.SQLFragment())
+	args := pgx.StrictNamedArgs{"id": id}
+	maps.Copy(args, scope.SQLArguments())
+	_, err := conn.Exec(ctx, q, args)
+	return err
+}

pkg/coredata/risk_assessment_process_order_field.go

@@ -0,0 +1,34 @@
+// Copyright (c) 2026 Probo Inc <hello@getprobo.com>.
+//
+// Permission to use, copy, modify, and/or distribute this software for any
+// purpose with or without fee is hereby granted, provided that the above
+// copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+// REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+// AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+// INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+// LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+// OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+package coredata
+
+type RiskAssessmentProcessOrderField string
+
+const (
+	RiskAssessmentProcessOrderFieldCreatedAt RiskAssessmentProcessOrderField = "CREATED_AT"
+	RiskAssessmentProcessOrderFieldName      RiskAssessmentProcessOrderField = "NAME"
+)
+
+func (p RiskAssessmentProcessOrderField) Column() string { return string(p) }
+func (p RiskAssessmentProcessOrderField) String() string { return string(p) }
+
+func (p RiskAssessmentProcessOrderField) MarshalText() ([]byte, error) {
+	return []byte(p.String()), nil
+}
+
+func (p *RiskAssessmentProcessOrderField) UnmarshalText(text []byte) error {
+	*p = RiskAssessmentProcessOrderField(text)
+	return nil
+}

pkg/coredata/risk_assessment_scenario.go

@@ -0,0 +1,398 @@
+// Copyright (c) 2026 Probo Inc <hello@getprobo.com>.
+//
+// Permission to use, copy, modify, and/or distribute this software for any
+// purpose with or without fee is hereby granted, provided that the above
+// copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+// REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+// AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+// INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+// LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+// OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+package coredata
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"maps"
+	"time"
+
+	"github.com/jackc/pgx/v5"
+	"github.com/jackc/pgx/v5/pgconn"
+	"go.gearno.de/kit/pg"
+	"go.probo.inc/probo/pkg/gid"
+	"go.probo.inc/probo/pkg/page"
+)
+
+type (
+	RiskAssessmentScenario struct {
+		ID                    gid.GID   `db:"id"`
+		OrganizationID        gid.GID   `db:"organization_id"`
+		RiskAssessmentScopeID gid.GID   `db:"risk_assessment_scope_id"`
+		Name                  string    `db:"name"`
+		Description           *string   `db:"description"`
+		CreatedAt             time.Time `db:"created_at"`
+		UpdatedAt             time.Time `db:"updated_at"`
+	}
+
+	RiskAssessmentScenarios []*RiskAssessmentScenario
+)
+
+func (s *RiskAssessmentScenario) CursorKey(orderBy RiskAssessmentScenarioOrderField) page.CursorKey {
+	switch orderBy {
+	case RiskAssessmentScenarioOrderFieldCreatedAt:
+		return page.CursorKey{ID: s.ID, Value: s.CreatedAt}
+	case RiskAssessmentScenarioOrderFieldName:
+		return page.CursorKey{ID: s.ID, Value: s.Name}
+	}
+	panic(fmt.Sprintf("unsupported order by: %s", orderBy))
+}
+
+func (s *RiskAssessmentScenario) AuthorizationAttributes(ctx context.Context, conn pg.Querier) (map[string]string, error) {
+	q := `SELECT organization_id FROM risk_assessment_scenarios WHERE id = $1 LIMIT 1;`
+
+	var organizationID gid.GID
+	if err := conn.QueryRow(ctx, q, s.ID).Scan(&organizationID); err != nil {
+		if errors.Is(err, pgx.ErrNoRows) {
+			return nil, ErrResourceNotFound
+		}
+		return nil, fmt.Errorf("cannot query risk scenario authorization attributes: %w", err)
+	}
+
+	return map[string]string{"organization_id": organizationID.String()}, nil
+}
+
+func (ss *RiskAssessmentScenarios) LoadByOrganizationID(
+	ctx context.Context,
+	conn pg.Querier,
+	scope Scoper,
+	organizationID gid.GID,
+	cursor *page.Cursor[RiskAssessmentScenarioOrderField],
+) error {
+	q := `
+SELECT
+	id,
+	organization_id,
+	risk_assessment_scope_id,
+	name,
+	description,
+	created_at,
+	updated_at
+FROM
+	risk_assessment_scenarios
+WHERE
+	%s
+	AND organization_id = @organization_id
+	AND %s
+`
+	q = fmt.Sprintf(q, scope.SQLFragment(), cursor.SQLFragment())
+	args := pgx.NamedArgs{"organization_id": organizationID}
+	maps.Copy(args, scope.SQLArguments())
+	maps.Copy(args, cursor.SQLArguments())
+
+	rows, err := conn.Query(ctx, q, args)
+	if err != nil {
+		return fmt.Errorf("cannot query risk scenarios: %w", err)
+	}
+	results, err := pgx.CollectRows(rows, pgx.RowToAddrOfStructByName[RiskAssessmentScenario])
+	if err != nil {
+		return fmt.Errorf("cannot collect risk scenarios: %w", err)
+	}
+	*ss = results
+	return nil
+}
+
+func (ss *RiskAssessmentScenarios) CountByOrganizationID(
+	ctx context.Context,
+	conn pg.Querier,
+	scope Scoper,
+	organizationID gid.GID,
+) (int, error) {
+	q := `
+SELECT
+	COUNT(id)
+FROM
+	risk_assessment_scenarios
+WHERE
+	%s
+	AND organization_id = @organization_id
+`
+	q = fmt.Sprintf(q, scope.SQLFragment())
+	args := pgx.NamedArgs{"organization_id": organizationID}
+	maps.Copy(args, scope.SQLArguments())
+
+	var count int
+	if err := conn.QueryRow(ctx, q, args).Scan(&count); err != nil {
+		return 0, fmt.Errorf("cannot count risk scenarios: %w", err)
+	}
+	return count, nil
+}
+
+func (ss *RiskAssessmentScenarios) LoadByRiskID(
+	ctx context.Context,
+	conn pg.Querier,
+	scope Scoper,
+	riskID gid.GID,
+	cursor *page.Cursor[RiskAssessmentScenarioOrderField],
+) error {
+	q := `
+WITH linked_scenarios AS (
+	SELECT
+		risk_assessment_scenario_id
+	FROM
+		risk_assessment_scenario_risks
+	WHERE
+		%s
+		AND risk_id = @risk_id
+)
+SELECT
+	id,
+	organization_id,
+	risk_assessment_scope_id,
+	name,
+	description,
+	created_at,
+	updated_at
+FROM
+	risk_assessment_scenarios
+WHERE
+	%s
+	AND id IN (SELECT risk_assessment_scenario_id FROM linked_scenarios)
+	AND %s
+`
+	q = fmt.Sprintf(q, scope.SQLFragment(), scope.SQLFragment(), cursor.SQLFragment())
+	args := pgx.NamedArgs{"risk_id": riskID}
+	maps.Copy(args, scope.SQLArguments())
+	maps.Copy(args, cursor.SQLArguments())
+
+	rows, err := conn.Query(ctx, q, args)
+	if err != nil {
+		return fmt.Errorf("cannot query risk scenarios: %w", err)
+	}
+	results, err := pgx.CollectRows(rows, pgx.RowToAddrOfStructByName[RiskAssessmentScenario])
+	if err != nil {
+		return fmt.Errorf("cannot collect risk scenarios: %w", err)
+	}
+	*ss = results
+	return nil
+}
+
+func (ss *RiskAssessmentScenarios) CountByRiskID(
+	ctx context.Context,
+	conn pg.Querier,
+	scope Scoper,
+	riskID gid.GID,
+) (int, error) {
+	q := `
+WITH linked_scenarios AS (
+	SELECT
+		risk_assessment_scenario_id
+	FROM
+		risk_assessment_scenario_risks
+	WHERE
+		%s
+		AND risk_id = @risk_id
+)
+SELECT
+	COUNT(id)
+FROM
+	risk_assessment_scenarios
+WHERE
+	%s
+	AND id IN (SELECT risk_assessment_scenario_id FROM linked_scenarios)
+`
+	q = fmt.Sprintf(q, scope.SQLFragment(), scope.SQLFragment())
+	args := pgx.NamedArgs{"risk_id": riskID}
+	maps.Copy(args, scope.SQLArguments())
+
+	var count int
+	if err := conn.QueryRow(ctx, q, args).Scan(&count); err != nil {
+		return 0, fmt.Errorf("cannot count risk scenarios: %w", err)
+	}
+	return count, nil
+}
+
+func (ss *RiskAssessmentScenarios) LoadByRiskAssessmentScopeID(
+	ctx context.Context,
+	conn pg.Querier,
+	scope Scoper,
+	riskAssessmentScopeID gid.GID,
+	cursor *page.Cursor[RiskAssessmentScenarioOrderField],
+) error {
+	q := `
+SELECT
+	id,
+	organization_id,
+	risk_assessment_scope_id,
+	name,
+	description,
+	created_at,
+	updated_at
+FROM
+	risk_assessment_scenarios
+WHERE
+	%s
+	AND risk_assessment_scope_id = @risk_assessment_scope_id
+	AND %s
+`
+	q = fmt.Sprintf(q, scope.SQLFragment(), cursor.SQLFragment())
+	args := pgx.NamedArgs{"risk_assessment_scope_id": riskAssessmentScopeID}
+	maps.Copy(args, scope.SQLArguments())
+	maps.Copy(args, cursor.SQLArguments())
+
+	rows, err := conn.Query(ctx, q, args)
+	if err != nil {
+		return fmt.Errorf("cannot query risk scenarios: %w", err)
+	}
+	results, err := pgx.CollectRows(rows, pgx.RowToAddrOfStructByName[RiskAssessmentScenario])
+	if err != nil {
+		return fmt.Errorf("cannot collect risk scenarios: %w", err)
+	}
+	*ss = results
+	return nil
+}
+
+func (ss *RiskAssessmentScenarios) CountByRiskAssessmentScopeID(
+	ctx context.Context,
+	conn pg.Querier,
+	scope Scoper,
+	riskAssessmentScopeID gid.GID,
+) (int, error) {
+	q := `
+SELECT
+	COUNT(id)
+FROM
+	risk_assessment_scenarios
+WHERE
+	%s
+	AND risk_assessment_scope_id = @risk_assessment_scope_id
+`
+	q = fmt.Sprintf(q, scope.SQLFragment())
+	args := pgx.NamedArgs{"risk_assessment_scope_id": riskAssessmentScopeID}
+	maps.Copy(args, scope.SQLArguments())
+
+	var count int
+	if err := conn.QueryRow(ctx, q, args).Scan(&count); err != nil {
+		return 0, fmt.Errorf("cannot count risk scenarios: %w", err)
+	}
+	return count, nil
+}
+
+func (s *RiskAssessmentScenario) LoadByID(ctx context.Context, conn pg.Querier, scope Scoper, id gid.GID) error {
+	q := `
+SELECT
+	id,
+	organization_id,
+	risk_assessment_scope_id,
+	name,
+	description,
+	created_at,
+	updated_at
+FROM
+	risk_assessment_scenarios
+WHERE
+	%s
+	AND id = @id
+LIMIT 1
+`
+	q = fmt.Sprintf(q, scope.SQLFragment())
+	args := pgx.StrictNamedArgs{"id": id}
+	maps.Copy(args, scope.SQLArguments())
+	rows, err := conn.Query(ctx, q, args)
+	if err != nil {
+		return fmt.Errorf("cannot query risk scenario: %w", err)
+	}
+	result, err := pgx.CollectExactlyOneRow(rows, pgx.RowToStructByName[RiskAssessmentScenario])
+	if err != nil {
+		if errors.Is(err, pgx.ErrNoRows) {
+			return ErrResourceNotFound
+		}
+		return fmt.Errorf("cannot collect risk scenario: %w", err)
+	}
+	*s = result
+	return nil
+}
+
+func (s *RiskAssessmentScenario) Insert(ctx context.Context, conn pg.Tx, scope Scoper) error {
+	q := `
+INSERT INTO risk_assessment_scenarios (
+	id,
+	tenant_id,
+	organization_id,
+	risk_assessment_scope_id,
+	name,
+	description,
+	created_at,
+	updated_at
+) VALUES (
+	@id,
+	@tenant_id,
+	@organization_id,
+	@risk_assessment_scope_id,
+	@name,
+	@description,
+	@created_at,
+	@updated_at
+)
+`
+	args := pgx.StrictNamedArgs{
+		"id":                       s.ID,
+		"tenant_id":                scope.GetTenantID(),
+		"organization_id":          s.OrganizationID,
+		"risk_assessment_scope_id": s.RiskAssessmentScopeID,
+		"name":                     s.Name,
+		"description":              s.Description,
+		"created_at":               s.CreatedAt,
+		"updated_at":               s.UpdatedAt,
+	}
+	_, err := conn.Exec(ctx, q, args)
+	if err != nil {
+		if pgErr, ok := errors.AsType[*pgconn.PgError](err); ok && pgErr.Code == "23505" {
+			return ErrResourceAlreadyExists
+		}
+		return fmt.Errorf("cannot insert risk scenario: %w", err)
+	}
+	return nil
+}
+
+func (s *RiskAssessmentScenario) Update(ctx context.Context, conn pg.Tx, scope Scoper) error {
+	q := `
+UPDATE risk_assessment_scenarios
+SET
+	name = @name,
+	description = @description,
+	updated_at = @updated_at
+WHERE
+	%s
+	AND id = @id
+`
+	q = fmt.Sprintf(q, scope.SQLFragment())
+	args := pgx.StrictNamedArgs{"id": s.ID, "name": s.Name, "description": s.Description, "updated_at": s.UpdatedAt}
+	maps.Copy(args, scope.SQLArguments())
+	result, err := conn.Exec(ctx, q, args)
+	if err != nil {
+		return fmt.Errorf("cannot update risk scenario: %w", err)
+	}
+	if result.RowsAffected() == 0 {
+		return ErrResourceNotFound
+	}
+	return nil
+}
+
+func (s *RiskAssessmentScenario) Delete(ctx context.Context, conn pg.Tx, scope Scoper, id gid.GID) error {
+	q := `
+DELETE FROM risk_assessment_scenarios
+WHERE
+	%s
+	AND id = @id
+`
+	q = fmt.Sprintf(q, scope.SQLFragment())
+	args := pgx.StrictNamedArgs{"id": id}
+	maps.Copy(args, scope.SQLArguments())
+	_, err := conn.Exec(ctx, q, args)
+	return err
+}

pkg/coredata/risk_assessment_scenario_order_field.go

@@ -0,0 +1,34 @@
+// Copyright (c) 2026 Probo Inc <hello@getprobo.com>.
+//
+// Permission to use, copy, modify, and/or distribute this software for any
+// purpose with or without fee is hereby granted, provided that the above
+// copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+// REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+// AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+// INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+// LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+// OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+package coredata
+
+type RiskAssessmentScenarioOrderField string
+
+const (
+	RiskAssessmentScenarioOrderFieldCreatedAt RiskAssessmentScenarioOrderField = "CREATED_AT"
+	RiskAssessmentScenarioOrderFieldName      RiskAssessmentScenarioOrderField = "NAME"
+)
+
+func (p RiskAssessmentScenarioOrderField) Column() string { return string(p) }
+func (p RiskAssessmentScenarioOrderField) String() string { return string(p) }
+
+func (p RiskAssessmentScenarioOrderField) MarshalText() ([]byte, error) {
+	return []byte(p.String()), nil
+}
+
+func (p *RiskAssessmentScenarioOrderField) UnmarshalText(text []byte) error {
+	*p = RiskAssessmentScenarioOrderField(text)
+	return nil
+}

pkg/coredata/risk_assessment_scenario_risk.go

@@ -0,0 +1,181 @@
+// Copyright (c) 2026 Probo Inc <hello@getprobo.com>.
+//
+// Permission to use, copy, modify, and/or distribute this software for any
+// purpose with or without fee is hereby granted, provided that the above
+// copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+// REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+// AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+// INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+// LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+// OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+package coredata
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"maps"
+	"time"
+
+	"github.com/jackc/pgx/v5"
+	"github.com/jackc/pgx/v5/pgconn"
+	"go.gearno.de/kit/pg"
+	"go.probo.inc/probo/pkg/gid"
+	"go.probo.inc/probo/pkg/page"
+)
+
+type (
+	RiskAssessmentScenarioRisk struct {
+		RiskAssessmentScenarioID gid.GID   `db:"risk_assessment_scenario_id"`
+		RiskID                   gid.GID   `db:"risk_id"`
+		CreatedAt                time.Time `db:"created_at"`
+	}
+
+	RiskAssessmentScenarioRisks []*RiskAssessmentScenarioRisk
+)
+
+func (sr *RiskAssessmentScenarioRisk) Insert(ctx context.Context, conn pg.Tx, scope Scoper) error {
+	q := `
+INSERT INTO risk_assessment_scenario_risks (
+	tenant_id,
+	risk_assessment_scenario_id,
+	risk_id,
+	created_at
+) VALUES (
+	@tenant_id,
+	@risk_assessment_scenario_id,
+	@risk_id,
+	@created_at
+)
+`
+	args := pgx.StrictNamedArgs{
+		"tenant_id":                   scope.GetTenantID(),
+		"risk_assessment_scenario_id": sr.RiskAssessmentScenarioID,
+		"risk_id":                     sr.RiskID,
+		"created_at":                  sr.CreatedAt,
+	}
+	_, err := conn.Exec(ctx, q, args)
+	if err != nil {
+		if pgErr, ok := errors.AsType[*pgconn.PgError](err); ok && pgErr.Code == "23505" {
+			return ErrResourceAlreadyExists
+		}
+		return fmt.Errorf("cannot insert risk scenario risk: %w", err)
+	}
+	return nil
+}
+
+func (sr *RiskAssessmentScenarioRisk) Delete(ctx context.Context, conn pg.Tx, scope Scoper) error {
+	q := `
+DELETE FROM risk_assessment_scenario_risks
+WHERE
+	%s
+	AND risk_assessment_scenario_id = @risk_assessment_scenario_id
+	AND risk_id = @risk_id
+`
+	q = fmt.Sprintf(q, scope.SQLFragment())
+	args := pgx.StrictNamedArgs{
+		"risk_assessment_scenario_id": sr.RiskAssessmentScenarioID,
+		"risk_id":                     sr.RiskID,
+	}
+	maps.Copy(args, scope.SQLArguments())
+	_, err := conn.Exec(ctx, q, args)
+	return err
+}
+
+func (rs *Risks) LoadByScenarioID(
+	ctx context.Context,
+	conn pg.Querier,
+	scope Scoper,
+	scenarioID gid.GID,
+	cursor *page.Cursor[RiskOrderField],
+) error {
+	q := `
+WITH linked_risks AS (
+	SELECT
+		risk_id
+	FROM
+		risk_assessment_scenario_risks
+	WHERE
+		%s
+		AND risk_assessment_scenario_id = @scenario_id
+)
+SELECT
+	id,
+	organization_id,
+	name,
+	description,
+	category,
+	treatment,
+	inherent_likelihood,
+	inherent_impact,
+	inherent_risk_score,
+	residual_likelihood,
+	residual_impact,
+	residual_risk_score,
+	owner_profile_id,
+	NULL AS owner_full_name,
+	note,
+	created_at,
+	updated_at
+FROM
+	risks
+WHERE
+	%s
+	AND id IN (SELECT risk_id FROM linked_risks)
+	AND %s
+`
+	q = fmt.Sprintf(q, scope.SQLFragment(), scope.SQLFragment(), cursor.SQLFragment())
+	args := pgx.NamedArgs{"scenario_id": scenarioID}
+	maps.Copy(args, scope.SQLArguments())
+	maps.Copy(args, cursor.SQLArguments())
+
+	rows, err := conn.Query(ctx, q, args)
+	if err != nil {
+		return fmt.Errorf("cannot query risk scenario risks: %w", err)
+	}
+	results, err := pgx.CollectRows(rows, pgx.RowToAddrOfStructByName[Risk])
+	if err != nil {
+		return fmt.Errorf("cannot collect risk scenario risks: %w", err)
+	}
+	*rs = results
+	return nil
+}
+
+func (rs *Risks) CountByScenarioID(
+	ctx context.Context,
+	conn pg.Querier,
+	scope Scoper,
+	scenarioID gid.GID,
+) (int, error) {
+	q := `
+WITH linked_risks AS (
+	SELECT
+		risk_id
+	FROM
+		risk_assessment_scenario_risks
+	WHERE
+		%s
+		AND risk_assessment_scenario_id = @scenario_id
+)
+SELECT
+	COUNT(id)
+FROM
+	risks
+WHERE
+	%s
+	AND id IN (SELECT risk_id FROM linked_risks)
+`
+	q = fmt.Sprintf(q, scope.SQLFragment(), scope.SQLFragment())
+	args := pgx.NamedArgs{"scenario_id": scenarioID}
+	maps.Copy(args, scope.SQLArguments())
+
+	var count int
+	if err := conn.QueryRow(ctx, q, args).Scan(&count); err != nil {
+		return 0, fmt.Errorf("cannot count risk scenario risks: %w", err)
+	}
+	return count, nil
+}

pkg/coredata/risk_assessment_scenario_threat.go

@@ -0,0 +1,172 @@
+// Copyright (c) 2026 Probo Inc <hello@getprobo.com>.
+//
+// Permission to use, copy, modify, and/or distribute this software for any
+// purpose with or without fee is hereby granted, provided that the above
+// copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+// REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+// AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+// INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+// LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+// OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+package coredata
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"maps"
+	"time"
+
+	"github.com/jackc/pgx/v5"
+	"github.com/jackc/pgx/v5/pgconn"
+	"go.gearno.de/kit/pg"
+	"go.probo.inc/probo/pkg/gid"
+	"go.probo.inc/probo/pkg/page"
+)
+
+type (
+	RiskAssessmentScenarioThreat struct {
+		RiskAssessmentScenarioID gid.GID   `db:"risk_assessment_scenario_id"`
+		RiskAssessmentThreatID   gid.GID   `db:"risk_assessment_threat_id"`
+		CreatedAt                time.Time `db:"created_at"`
+	}
+
+	RiskAssessmentScenarioThreats []*RiskAssessmentScenarioThreat
+)
+
+func (st *RiskAssessmentScenarioThreat) Insert(ctx context.Context, conn pg.Tx, scope Scoper) error {
+	q := `
+INSERT INTO risk_assessment_scenario_threats (
+	tenant_id,
+	risk_assessment_scenario_id,
+	risk_assessment_threat_id,
+	created_at
+) VALUES (
+	@tenant_id,
+	@risk_assessment_scenario_id,
+	@risk_assessment_threat_id,
+	@created_at
+)
+`
+	args := pgx.StrictNamedArgs{
+		"tenant_id":                   scope.GetTenantID(),
+		"risk_assessment_scenario_id": st.RiskAssessmentScenarioID,
+		"risk_assessment_threat_id":   st.RiskAssessmentThreatID,
+		"created_at":                  st.CreatedAt,
+	}
+	_, err := conn.Exec(ctx, q, args)
+	if err != nil {
+		if pgErr, ok := errors.AsType[*pgconn.PgError](err); ok && pgErr.Code == "23505" {
+			return ErrResourceAlreadyExists
+		}
+		return fmt.Errorf("cannot insert risk scenario threat: %w", err)
+	}
+	return nil
+}
+
+func (st *RiskAssessmentScenarioThreat) Delete(ctx context.Context, conn pg.Tx, scope Scoper) error {
+	q := `
+DELETE FROM risk_assessment_scenario_threats
+WHERE
+	%s
+	AND risk_assessment_scenario_id = @risk_assessment_scenario_id
+	AND risk_assessment_threat_id = @risk_assessment_threat_id
+`
+	q = fmt.Sprintf(q, scope.SQLFragment())
+	args := pgx.StrictNamedArgs{
+		"risk_assessment_scenario_id": st.RiskAssessmentScenarioID,
+		"risk_assessment_threat_id":   st.RiskAssessmentThreatID,
+	}
+	maps.Copy(args, scope.SQLArguments())
+	_, err := conn.Exec(ctx, q, args)
+	return err
+}
+
+func (ts *RiskAssessmentThreats) LoadByScenarioID(
+	ctx context.Context,
+	conn pg.Querier,
+	scope Scoper,
+	scenarioID gid.GID,
+	cursor *page.Cursor[RiskAssessmentThreatOrderField],
+) error {
+	q := `
+WITH linked_threats AS (
+	SELECT
+		risk_assessment_threat_id
+	FROM
+		risk_assessment_scenario_threats
+	WHERE
+		%s
+		AND risk_assessment_scenario_id = @scenario_id
+)
+SELECT
+	id,
+	organization_id,
+	risk_assessment_scope_id,
+	process_id,
+	name,
+	category,
+	created_at,
+	updated_at
+FROM
+	risk_assessment_threats
+WHERE
+	%s
+	AND id IN (SELECT risk_assessment_threat_id FROM linked_threats)
+	AND %s
+`
+	q = fmt.Sprintf(q, scope.SQLFragment(), scope.SQLFragment(), cursor.SQLFragment())
+	args := pgx.NamedArgs{"scenario_id": scenarioID}
+	maps.Copy(args, scope.SQLArguments())
+	maps.Copy(args, cursor.SQLArguments())
+
+	rows, err := conn.Query(ctx, q, args)
+	if err != nil {
+		return fmt.Errorf("cannot query risk scenario threats: %w", err)
+	}
+	results, err := pgx.CollectRows(rows, pgx.RowToAddrOfStructByName[RiskAssessmentThreat])
+	if err != nil {
+		return fmt.Errorf("cannot collect risk scenario threats: %w", err)
+	}
+	*ts = results
+	return nil
+}
+
+func (ts *RiskAssessmentThreats) CountByScenarioID(
+	ctx context.Context,
+	conn pg.Querier,
+	scope Scoper,
+	scenarioID gid.GID,
+) (int, error) {
+	q := `
+WITH linked_threats AS (
+	SELECT
+		risk_assessment_threat_id
+	FROM
+		risk_assessment_scenario_threats
+	WHERE
+		%s
+		AND risk_assessment_scenario_id = @scenario_id
+)
+SELECT
+	COUNT(id)
+FROM
+	risk_assessment_threats
+WHERE
+	%s
+	AND id IN (SELECT risk_assessment_threat_id FROM linked_threats)
+`
+	q = fmt.Sprintf(q, scope.SQLFragment(), scope.SQLFragment())
+	args := pgx.NamedArgs{"scenario_id": scenarioID}
+	maps.Copy(args, scope.SQLArguments())
+
+	var count int
+	if err := conn.QueryRow(ctx, q, args).Scan(&count); err != nil {
+		return 0, fmt.Errorf("cannot count risk scenario threats: %w", err)
+	}
+	return count, nil
+}

pkg/coredata/risk_assessment_scope.go

@@ -0,0 +1,242 @@
+// Copyright (c) 2026 Probo Inc <hello@getprobo.com>.
+//
+// Permission to use, copy, modify, and/or distribute this software for any
+// purpose with or without fee is hereby granted, provided that the above
+// copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+// REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+// AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+// INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+// LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+// OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+package coredata
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"maps"
+	"time"
+
+	"github.com/jackc/pgx/v5"
+	"github.com/jackc/pgx/v5/pgconn"
+	"go.gearno.de/kit/pg"
+	"go.probo.inc/probo/pkg/gid"
+	"go.probo.inc/probo/pkg/page"
+)
+
+type (
+	RiskAssessmentScope struct {
+		ID               gid.GID   `db:"id"`
+		OrganizationID   gid.GID   `db:"organization_id"`
+		RiskAssessmentID gid.GID   `db:"risk_assessment_id"`
+		Name             string    `db:"name"`
+		CreatedAt        time.Time `db:"created_at"`
+		UpdatedAt        time.Time `db:"updated_at"`
+	}
+
+	RiskAssessmentScopes []*RiskAssessmentScope
+)
+
+func (s *RiskAssessmentScope) CursorKey(orderBy RiskAssessmentScopeOrderField) page.CursorKey {
+	switch orderBy {
+	case RiskAssessmentScopeOrderFieldCreatedAt:
+		return page.CursorKey{ID: s.ID, Value: s.CreatedAt}
+	case RiskAssessmentScopeOrderFieldName:
+		return page.CursorKey{ID: s.ID, Value: s.Name}
+	}
+	panic(fmt.Sprintf("unsupported order by: %s", orderBy))
+}
+
+func (s *RiskAssessmentScope) AuthorizationAttributes(ctx context.Context, conn pg.Querier) (map[string]string, error) {
+	q := `SELECT organization_id FROM risk_assessment_scopes WHERE id = $1 LIMIT 1;`
+
+	var organizationID gid.GID
+	if err := conn.QueryRow(ctx, q, s.ID).Scan(&organizationID); err != nil {
+		if errors.Is(err, pgx.ErrNoRows) {
+			return nil, ErrResourceNotFound
+		}
+		return nil, fmt.Errorf("cannot query risk assessment scope authorization attributes: %w", err)
+	}
+
+	return map[string]string{"organization_id": organizationID.String()}, nil
+}
+
+func (ss *RiskAssessmentScopes) LoadByRiskAssessmentID(
+	ctx context.Context,
+	conn pg.Querier,
+	scope Scoper,
+	riskAssessmentID gid.GID,
+	cursor *page.Cursor[RiskAssessmentScopeOrderField],
+) error {
+	q := `
+SELECT
+	id,
+	organization_id,
+	risk_assessment_id,
+	name,
+	created_at,
+	updated_at
+FROM
+	risk_assessment_scopes
+WHERE
+	%s
+	AND risk_assessment_id = @risk_assessment_id
+	AND %s
+`
+	q = fmt.Sprintf(q, scope.SQLFragment(), cursor.SQLFragment())
+	args := pgx.NamedArgs{"risk_assessment_id": riskAssessmentID}
+	maps.Copy(args, scope.SQLArguments())
+	maps.Copy(args, cursor.SQLArguments())
+
+	rows, err := conn.Query(ctx, q, args)
+	if err != nil {
+		return fmt.Errorf("cannot query risk assessment scopes: %w", err)
+	}
+	results, err := pgx.CollectRows(rows, pgx.RowToAddrOfStructByName[RiskAssessmentScope])
+	if err != nil {
+		return fmt.Errorf("cannot collect risk assessment scopes: %w", err)
+	}
+	*ss = results
+	return nil
+}
+
+func (ss *RiskAssessmentScopes) CountByRiskAssessmentID(
+	ctx context.Context,
+	conn pg.Querier,
+	scope Scoper,
+	riskAssessmentID gid.GID,
+) (int, error) {
+	q := `
+SELECT
+	COUNT(id)
+FROM
+	risk_assessment_scopes
+WHERE
+	%s
+	AND risk_assessment_id = @risk_assessment_id
+`
+
+	q = fmt.Sprintf(q, scope.SQLFragment())
+	args := pgx.NamedArgs{"risk_assessment_id": riskAssessmentID}
+	maps.Copy(args, scope.SQLArguments())
+
+	var count int
+	if err := conn.QueryRow(ctx, q, args).Scan(&count); err != nil {
+		return 0, fmt.Errorf("cannot count risk assessment scopes: %w", err)
+	}
+	return count, nil
+}
+
+func (s *RiskAssessmentScope) LoadByID(ctx context.Context, conn pg.Querier, scope Scoper, id gid.GID) error {
+	q := `
+SELECT
+	id,
+	organization_id,
+	risk_assessment_id,
+	name,
+	created_at,
+	updated_at
+FROM
+	risk_assessment_scopes
+WHERE
+	%s
+	AND id = @id
+LIMIT 1
+`
+	q = fmt.Sprintf(q, scope.SQLFragment())
+	args := pgx.StrictNamedArgs{"id": id}
+	maps.Copy(args, scope.SQLArguments())
+	rows, err := conn.Query(ctx, q, args)
+	if err != nil {
+		return fmt.Errorf("cannot query risk assessment scope: %w", err)
+	}
+	result, err := pgx.CollectExactlyOneRow(rows, pgx.RowToStructByName[RiskAssessmentScope])
+	if err != nil {
+		if errors.Is(err, pgx.ErrNoRows) {
+			return ErrResourceNotFound
+		}
+		return fmt.Errorf("cannot collect risk assessment scope: %w", err)
+	}
+	*s = result
+	return nil
+}
+
+func (s *RiskAssessmentScope) Insert(ctx context.Context, conn pg.Tx, scope Scoper) error {
+	q := `
+INSERT INTO risk_assessment_scopes (
+	id,
+	tenant_id,
+	organization_id,
+	risk_assessment_id,
+	name,
+	created_at,
+	updated_at
+) VALUES (
+	@id,
+	@tenant_id,
+	@organization_id,
+	@risk_assessment_id,
+	@name,
+	@created_at,
+	@updated_at
+)
+`
+	args := pgx.StrictNamedArgs{
+		"id":                 s.ID,
+		"tenant_id":          scope.GetTenantID(),
+		"organization_id":    s.OrganizationID,
+		"risk_assessment_id": s.RiskAssessmentID,
+		"name":               s.Name,
+		"created_at":         s.CreatedAt,
+		"updated_at":         s.UpdatedAt,
+	}
+	_, err := conn.Exec(ctx, q, args)
+	if err != nil {
+		if pgErr, ok := errors.AsType[*pgconn.PgError](err); ok && pgErr.Code == "23505" {
+			return ErrResourceAlreadyExists
+		}
+		return fmt.Errorf("cannot insert risk assessment scope: %w", err)
+	}
+	return nil
+}
+
+func (s *RiskAssessmentScope) Update(ctx context.Context, conn pg.Tx, scope Scoper) error {
+	q := `
+UPDATE risk_assessment_scopes
+SET
+	name = @name,
+	updated_at = @updated_at
+WHERE
+	%s
+	AND id = @id
+`
+	q = fmt.Sprintf(q, scope.SQLFragment())
+	args := pgx.StrictNamedArgs{"id": s.ID, "name": s.Name, "updated_at": s.UpdatedAt}
+	maps.Copy(args, scope.SQLArguments())
+	result, err := conn.Exec(ctx, q, args)
+	if err != nil {
+		return fmt.Errorf("cannot update risk assessment scope: %w", err)
+	}
+	if result.RowsAffected() == 0 {
+		return ErrResourceNotFound
+	}
+	return nil
+}
+
+func (s *RiskAssessmentScope) Delete(ctx context.Context, conn pg.Tx, scope Scoper, id gid.GID) error {
+	q := `
+DELETE FROM risk_assessment_scopes
+WHERE
+	%s
+	AND id = @id
+`
+	q = fmt.Sprintf(q, scope.SQLFragment())
+	args := pgx.StrictNamedArgs{"id": id}
+	maps.Copy(args, scope.SQLArguments())
+	_, err := conn.Exec(ctx, q, args)
+	return err
+}

pkg/coredata/risk_assessment_scope_order_field.go

@@ -0,0 +1,34 @@
+// Copyright (c) 2026 Probo Inc <hello@getprobo.com>.
+//
+// Permission to use, copy, modify, and/or distribute this software for any
+// purpose with or without fee is hereby granted, provided that the above
+// copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+// REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+// AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+// INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+// LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+// OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+package coredata
+
+type RiskAssessmentScopeOrderField string
+
+const (
+	RiskAssessmentScopeOrderFieldCreatedAt RiskAssessmentScopeOrderField = "CREATED_AT"
+	RiskAssessmentScopeOrderFieldName      RiskAssessmentScopeOrderField = "NAME"
+)
+
+func (p RiskAssessmentScopeOrderField) Column() string { return string(p) }
+func (p RiskAssessmentScopeOrderField) String() string { return string(p) }
+
+func (p RiskAssessmentScopeOrderField) MarshalText() ([]byte, error) {
+	return []byte(p.String()), nil
+}
+
+func (p *RiskAssessmentScopeOrderField) UnmarshalText(text []byte) error {
+	*p = RiskAssessmentScopeOrderField(text)
+	return nil
+}

pkg/coredata/risk_assessment_threat.go

@@ -0,0 +1,262 @@
+// Copyright (c) 2026 Probo Inc <hello@getprobo.com>.
+//
+// Permission to use, copy, modify, and/or distribute this software for any
+// purpose with or without fee is hereby granted, provided that the above
+// copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+// REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+// AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+// INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+// LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+// OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+package coredata
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"maps"
+	"time"
+
+	"github.com/jackc/pgx/v5"
+	"github.com/jackc/pgx/v5/pgconn"
+	"go.gearno.de/kit/pg"
+	"go.probo.inc/probo/pkg/gid"
+	"go.probo.inc/probo/pkg/page"
+)
+
+type (
+	RiskAssessmentThreat struct {
+		ID                    gid.GID   `db:"id"`
+		OrganizationID        gid.GID   `db:"organization_id"`
+		RiskAssessmentScopeID gid.GID   `db:"risk_assessment_scope_id"`
+		ProcessID             gid.GID   `db:"process_id"`
+		Name                  string    `db:"name"`
+		Category              string    `db:"category"`
+		CreatedAt             time.Time `db:"created_at"`
+		UpdatedAt             time.Time `db:"updated_at"`
+	}
+
+	RiskAssessmentThreats []*RiskAssessmentThreat
+)
+
+func (t *RiskAssessmentThreat) CursorKey(orderBy RiskAssessmentThreatOrderField) page.CursorKey {
+	switch orderBy {
+	case RiskAssessmentThreatOrderFieldCreatedAt:
+		return page.CursorKey{ID: t.ID, Value: t.CreatedAt}
+	case RiskAssessmentThreatOrderFieldName:
+		return page.CursorKey{ID: t.ID, Value: t.Name}
+	}
+	panic(fmt.Sprintf("unsupported order by: %s", orderBy))
+}
+
+func (t *RiskAssessmentThreat) AuthorizationAttributes(ctx context.Context, conn pg.Querier) (map[string]string, error) {
+	q := `SELECT organization_id FROM risk_assessment_threats WHERE id = $1 LIMIT 1;`
+
+	var organizationID gid.GID
+	if err := conn.QueryRow(ctx, q, t.ID).Scan(&organizationID); err != nil {
+		if errors.Is(err, pgx.ErrNoRows) {
+			return nil, ErrResourceNotFound
+		}
+		return nil, fmt.Errorf("cannot query risk assessment threat authorization attributes: %w", err)
+	}
+
+	return map[string]string{"organization_id": organizationID.String()}, nil
+}
+
+func (ts *RiskAssessmentThreats) LoadByRiskAssessmentScopeID(
+	ctx context.Context,
+	conn pg.Querier,
+	scope Scoper,
+	riskAssessmentScopeID gid.GID,
+	cursor *page.Cursor[RiskAssessmentThreatOrderField],
+) error {
+	q := `
+SELECT
+	id,
+	organization_id,
+	risk_assessment_scope_id,
+	process_id,
+	name,
+	category,
+	created_at,
+	updated_at
+FROM
+	risk_assessment_threats
+WHERE
+	%s
+	AND risk_assessment_scope_id = @risk_assessment_scope_id
+	AND %s
+`
+	q = fmt.Sprintf(q, scope.SQLFragment(), cursor.SQLFragment())
+	args := pgx.NamedArgs{"risk_assessment_scope_id": riskAssessmentScopeID}
+	maps.Copy(args, scope.SQLArguments())
+	maps.Copy(args, cursor.SQLArguments())
+
+	rows, err := conn.Query(ctx, q, args)
+	if err != nil {
+		return fmt.Errorf("cannot query risk threats: %w", err)
+	}
+	results, err := pgx.CollectRows(rows, pgx.RowToAddrOfStructByName[RiskAssessmentThreat])
+	if err != nil {
+		return fmt.Errorf("cannot collect risk threats: %w", err)
+	}
+	*ts = results
+	return nil
+}
+
+func (ts *RiskAssessmentThreats) CountByRiskAssessmentScopeID(
+	ctx context.Context,
+	conn pg.Querier,
+	scope Scoper,
+	riskAssessmentScopeID gid.GID,
+) (int, error) {
+	q := `
+SELECT
+	COUNT(id)
+FROM
+	risk_assessment_threats
+WHERE
+	%s
+	AND risk_assessment_scope_id = @risk_assessment_scope_id
+`
+
+	q = fmt.Sprintf(q, scope.SQLFragment())
+	args := pgx.NamedArgs{"risk_assessment_scope_id": riskAssessmentScopeID}
+	maps.Copy(args, scope.SQLArguments())
+
+	var count int
+	if err := conn.QueryRow(ctx, q, args).Scan(&count); err != nil {
+		return 0, fmt.Errorf("cannot count risk threats: %w", err)
+	}
+	return count, nil
+}
+
+func (t *RiskAssessmentThreat) LoadByID(ctx context.Context, conn pg.Querier, scope Scoper, id gid.GID) error {
+	q := `
+SELECT
+	id,
+	organization_id,
+	risk_assessment_scope_id,
+	process_id,
+	name,
+	category,
+	created_at,
+	updated_at
+FROM
+	risk_assessment_threats
+WHERE
+	%s
+	AND id = @id
+LIMIT 1;
+`
+	q = fmt.Sprintf(q, scope.SQLFragment())
+	args := pgx.StrictNamedArgs{"id": id}
+	maps.Copy(args, scope.SQLArguments())
+	rows, err := conn.Query(ctx, q, args)
+	if err != nil {
+		return fmt.Errorf("cannot query risk threat: %w", err)
+	}
+	result, err := pgx.CollectExactlyOneRow(rows, pgx.RowToStructByName[RiskAssessmentThreat])
+	if err != nil {
+		if errors.Is(err, pgx.ErrNoRows) {
+			return ErrResourceNotFound
+		}
+		return fmt.Errorf("cannot collect risk threat: %w", err)
+	}
+	*t = result
+	return nil
+}
+
+func (t *RiskAssessmentThreat) Insert(ctx context.Context, conn pg.Tx, scope Scoper) error {
+	q := `
+INSERT INTO risk_assessment_threats (
+	id,
+	tenant_id,
+	organization_id,
+	risk_assessment_scope_id,
+	process_id,
+	name,
+	category,
+	created_at,
+	updated_at
+) VALUES (
+	@id,
+	@tenant_id,
+	@organization_id,
+	@risk_assessment_scope_id,
+	@process_id,
+	@name,
+	@category,
+	@created_at,
+	@updated_at
+)
+`
+	args := pgx.StrictNamedArgs{
+		"id":                       t.ID,
+		"tenant_id":                scope.GetTenantID(),
+		"organization_id":          t.OrganizationID,
+		"risk_assessment_scope_id": t.RiskAssessmentScopeID,
+		"process_id":               t.ProcessID,
+		"name":                     t.Name,
+		"category":                 t.Category,
+		"created_at":               t.CreatedAt,
+		"updated_at":               t.UpdatedAt,
+	}
+	_, err := conn.Exec(ctx, q, args)
+	if err != nil {
+		if pgErr, ok := errors.AsType[*pgconn.PgError](err); ok && pgErr.Code == "23505" {
+			return ErrResourceAlreadyExists
+		}
+		return fmt.Errorf("cannot insert risk threat: %w", err)
+	}
+	return nil
+}
+
+func (t *RiskAssessmentThreat) Update(ctx context.Context, conn pg.Tx, scope Scoper) error {
+	q := `
+UPDATE risk_assessment_threats
+SET
+	process_id = @process_id,
+	name = @name,
+	category = @category,
+	updated_at = @updated_at
+WHERE
+	%s
+	AND id = @id
+`
+	q = fmt.Sprintf(q, scope.SQLFragment())
+	args := pgx.StrictNamedArgs{
+		"id":         t.ID,
+		"process_id": t.ProcessID,
+		"name":       t.Name,
+		"category":   t.Category,
+		"updated_at": t.UpdatedAt,
+	}
+	maps.Copy(args, scope.SQLArguments())
+	result, err := conn.Exec(ctx, q, args)
+	if err != nil {
+		return fmt.Errorf("cannot update risk threat: %w", err)
+	}
+	if result.RowsAffected() == 0 {
+		return ErrResourceNotFound
+	}
+	return nil
+}
+
+func (t *RiskAssessmentThreat) Delete(ctx context.Context, conn pg.Tx, scope Scoper, id gid.GID) error {
+	q := `
+DELETE FROM risk_assessment_threats
+WHERE
+	%s
+	AND id = @id
+`
+	q = fmt.Sprintf(q, scope.SQLFragment())
+	args := pgx.StrictNamedArgs{"id": id}
+	maps.Copy(args, scope.SQLArguments())
+	_, err := conn.Exec(ctx, q, args)
+	return err
+}

pkg/coredata/risk_assessment_threat_order_field.go

@@ -0,0 +1,34 @@
+// Copyright (c) 2026 Probo Inc <hello@getprobo.com>.
+//
+// Permission to use, copy, modify, and/or distribute this software for any
+// purpose with or without fee is hereby granted, provided that the above
+// copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+// REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+// AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+// INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+// LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+// OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+package coredata
+
+type RiskAssessmentThreatOrderField string
+
+const (
+	RiskAssessmentThreatOrderFieldCreatedAt RiskAssessmentThreatOrderField = "CREATED_AT"
+	RiskAssessmentThreatOrderFieldName      RiskAssessmentThreatOrderField = "NAME"
+)
+
+func (p RiskAssessmentThreatOrderField) Column() string { return string(p) }
+func (p RiskAssessmentThreatOrderField) String() string { return string(p) }
+
+func (p RiskAssessmentThreatOrderField) MarshalText() ([]byte, error) {
+	return []byte(p.String()), nil
+}
+
+func (p *RiskAssessmentThreatOrderField) UnmarshalText(text []byte) error {
+	*p = RiskAssessmentThreatOrderField(text)
+	return nil
+}

pkg/probo/actions.go

@@ -396,6 +396,56 @@ const (
 	ActionCookieCategoryUpdate = "core:cookie-category:update"
 	ActionCookieCategoryDelete = "core:cookie-category:delete"
 
+	// RiskAssessment actions
+	ActionRiskAssessmentGet    = "core:risk-assessment:get"
+	ActionRiskAssessmentList   = "core:risk-assessment:list"
+	ActionRiskAssessmentCreate = "core:risk-assessment:create"
+	ActionRiskAssessmentUpdate = "core:risk-assessment:update"
+	ActionRiskAssessmentDelete = "core:risk-assessment:delete"
+
+	// RiskAssessmentScope actions
+	ActionRiskAssessmentScopeGet    = "core:risk-assessment-scope:get"
+	ActionRiskAssessmentScopeList   = "core:risk-assessment-scope:list"
+	ActionRiskAssessmentScopeCreate = "core:risk-assessment-scope:create"
+	ActionRiskAssessmentScopeUpdate = "core:risk-assessment-scope:update"
+	ActionRiskAssessmentScopeDelete = "core:risk-assessment-scope:delete"
+
+	// RiskAssessmentNode actions
+	ActionRiskAssessmentNodeGet    = "core:risk-assessment-node:get"
+	ActionRiskAssessmentNodeList   = "core:risk-assessment-node:list"
+	ActionRiskAssessmentNodeCreate = "core:risk-assessment-node:create"
+	ActionRiskAssessmentNodeUpdate = "core:risk-assessment-node:update"
+	ActionRiskAssessmentNodeDelete = "core:risk-assessment-node:delete"
+
+	// RiskAssessmentProcess actions
+	ActionRiskAssessmentProcessGet    = "core:risk-assessment-process:get"
+	ActionRiskAssessmentProcessList   = "core:risk-assessment-process:list"
+	ActionRiskAssessmentProcessCreate = "core:risk-assessment-process:create"
+	ActionRiskAssessmentProcessUpdate = "core:risk-assessment-process:update"
+	ActionRiskAssessmentProcessDelete = "core:risk-assessment-process:delete"
+
+	// RiskAssessmentThreat actions
+	ActionRiskAssessmentThreatGet    = "core:risk-assessment-threat:get"
+	ActionRiskAssessmentThreatList   = "core:risk-assessment-threat:list"
+	ActionRiskAssessmentThreatCreate = "core:risk-assessment-threat:create"
+	ActionRiskAssessmentThreatUpdate = "core:risk-assessment-threat:update"
+	ActionRiskAssessmentThreatDelete = "core:risk-assessment-threat:delete"
+
+	// RiskAssessmentScenario actions
+	ActionRiskAssessmentScenarioGet    = "core:risk-assessment-scenario:get"
+	ActionRiskAssessmentScenarioList   = "core:risk-assessment-scenario:list"
+	ActionRiskAssessmentScenarioCreate = "core:risk-assessment-scenario:create"
+	ActionRiskAssessmentScenarioUpdate = "core:risk-assessment-scenario:update"
+	ActionRiskAssessmentScenarioDelete = "core:risk-assessment-scenario:delete"
+
+	// RiskAssessmentScenarioThreat actions
+	ActionRiskAssessmentScenarioThreatLink   = "core:risk-assessment-scenario-threat:create"
+	ActionRiskAssessmentScenarioThreatUnlink = "core:risk-assessment-scenario-threat:delete"
+
+	// RiskAssessmentScenarioRisk actions
+	ActionRiskAssessmentScenarioRiskLink   = "core:risk-assessment-scenario-risk:create"
+	ActionRiskAssessmentScenarioRiskUnlink = "core:risk-assessment-scenario-risk:delete"
+
 	// Cookie actions
 	ActionCookieGet    = "core:cookie:get"
 	ActionCookieList   = "core:cookie:list"

pkg/probo/policies.go

@@ -88,6 +88,12 @@ var ViewerPolicy = policy.NewPolicy(
 		ActionCookieCategoryGet, ActionCookieCategoryList,
 		ActionCookieGet, ActionCookieList,
 		ActionCookieConsentRecordList,
+		ActionRiskAssessmentGet, ActionRiskAssessmentList,
+		ActionRiskAssessmentScopeGet, ActionRiskAssessmentScopeList,
+		ActionRiskAssessmentNodeGet, ActionRiskAssessmentNodeList,
+		ActionRiskAssessmentProcessGet, ActionRiskAssessmentProcessList,
+		ActionRiskAssessmentThreatGet, ActionRiskAssessmentThreatList,
+		ActionRiskAssessmentScenarioGet, ActionRiskAssessmentScenarioList,
 	).WithSID("entity-read-access").When(organizationCondition),
 
 	policy.Allow(
@@ -154,6 +160,12 @@ var AuditorPolicy = policy.NewPolicy(
 		ActionFileGet, ActionFileDownloadUrl,
 		ActionStatementOfApplicabilityGet, ActionStatementOfApplicabilityList,
 		ActionApplicabilityStatementGet, ActionApplicabilityStatementList,
+		ActionRiskAssessmentGet, ActionRiskAssessmentList,
+		ActionRiskAssessmentScopeGet, ActionRiskAssessmentScopeList,
+		ActionRiskAssessmentNodeGet, ActionRiskAssessmentNodeList,
+		ActionRiskAssessmentProcessGet, ActionRiskAssessmentProcessList,
+		ActionRiskAssessmentThreatGet, ActionRiskAssessmentThreatList,
+		ActionRiskAssessmentScenarioGet, ActionRiskAssessmentScenarioList,
 	).WithSID("entity-read-access").When(organizationCondition),
 
 	policy.Allow(

pkg/probod/probod.go

@@ -65,6 +65,7 @@ import (
 	"go.probo.inc/probo/pkg/mailer"
 	"go.probo.inc/probo/pkg/mailman"
 	"go.probo.inc/probo/pkg/probo"
+	"go.probo.inc/probo/pkg/riskmanagement"
 	"go.probo.inc/probo/pkg/securecookie"
 	"go.probo.inc/probo/pkg/server"
 	"go.probo.inc/probo/pkg/server/trustedproxy"
@@ -526,6 +527,7 @@ func (impl *Implm) Run(
 	)
 
 	thirdPartyService := thirdparty.NewService(pgClient, fileService)
+	riskManagementService := riskmanagement.NewService(pgClient)
 
 	serverHandler, err := server.NewServer(
 		server.Config{
@@ -541,6 +543,7 @@ func (impl *Implm) Run(
 			CookieBanner:      cookieBannerService,
 			Geoloc:            geolocService,
 			ThirdParty:        thirdPartyService,
+			RiskManagement:    riskManagementService,
 			Slack:             slackService,
 			ConnectorRegistry: defaultConnectorRegistry,
 			BaseURL:           baseURL,

pkg/server/api/api.go

@@ -35,6 +35,7 @@ import (
 	"go.probo.inc/probo/pkg/iam"
 	"go.probo.inc/probo/pkg/mailman"
 	"go.probo.inc/probo/pkg/probo"
+	"go.probo.inc/probo/pkg/riskmanagement"
 	"go.probo.inc/probo/pkg/securecookie"
 	connect_v1 "go.probo.inc/probo/pkg/server/api/connect/v1"
 	console_v1 "go.probo.inc/probo/pkg/server/api/console/v1"
@@ -63,6 +64,7 @@ type (
 		CookieBanner      *cookiebanner.Service
 		Geoloc            *geoloc.Service
 		ThirdParty        *thirdparty.Service
+		RiskManagement    *riskmanagement.Service
 		Cookie            securecookie.Config
 		TokenSecret       string
 		ConnectorRegistry *connector.ConnectorRegistry
@@ -193,6 +195,7 @@ func NewServer(cfg Config) (*Server, error) {
 			cfg.BaseURL,
 			cfg.CustomDomainCname,
 			cfg.ThirdParty,
+			cfg.RiskManagement,
 		),
 		cookieBannerHandler: cookiebanner_v1.NewMux(
 			cfg.Logger.Named("cookiebanner.v1"),

pkg/server/api/console/v1/base_resolvers.go

@@ -111,6 +111,66 @@ func (r *queryResolver) Node(ctx context.Context, id gid.GID) (types.Node, error
 			}
 			return types.NewRisk(risk), nil
 		}
+	case coredata.RiskAssessmentEntityType:
+		action = probo.ActionRiskAssessmentGet
+		loadNode = func(ctx context.Context, id gid.GID) (types.Node, error) {
+			scope := coredata.NewScopeFromObjectID(id)
+			ra, err := r.riskManagement.Get(ctx, scope, id)
+			if err != nil {
+				return nil, err
+			}
+			return types.NewRiskAssessment(ra), nil
+		}
+	case coredata.RiskAssessmentNodeEntityType:
+		action = probo.ActionRiskAssessmentNodeGet
+		loadNode = func(ctx context.Context, id gid.GID) (types.Node, error) {
+			scope := coredata.NewScopeFromObjectID(id)
+			n, err := r.riskManagement.GetNode(ctx, scope, id)
+			if err != nil {
+				return nil, err
+			}
+			return types.NewRiskAssessmentNode(n), nil
+		}
+	case coredata.RiskAssessmentProcessEntityType:
+		action = probo.ActionRiskAssessmentProcessGet
+		loadNode = func(ctx context.Context, id gid.GID) (types.Node, error) {
+			scope := coredata.NewScopeFromObjectID(id)
+			p, err := r.riskManagement.GetProcess(ctx, scope, id)
+			if err != nil {
+				return nil, err
+			}
+			return types.NewRiskAssessmentProcess(p), nil
+		}
+	case coredata.RiskAssessmentThreatEntityType:
+		action = probo.ActionRiskAssessmentThreatGet
+		loadNode = func(ctx context.Context, id gid.GID) (types.Node, error) {
+			scope := coredata.NewScopeFromObjectID(id)
+			t, err := r.riskManagement.GetThreat(ctx, scope, id)
+			if err != nil {
+				return nil, err
+			}
+			return types.NewRiskAssessmentThreat(t), nil
+		}
+	case coredata.RiskAssessmentScopeEntityType:
+		action = probo.ActionRiskAssessmentScopeGet
+		loadNode = func(ctx context.Context, id gid.GID) (types.Node, error) {
+			scope := coredata.NewScopeFromObjectID(id)
+			s, err := r.riskManagement.GetScope(ctx, scope, id)
+			if err != nil {
+				return nil, err
+			}
+			return types.NewRiskAssessmentScope(s), nil
+		}
+	case coredata.RiskAssessmentScenarioEntityType:
+		action = probo.ActionRiskAssessmentScenarioGet
+		loadNode = func(ctx context.Context, id gid.GID) (types.Node, error) {
+			scope := coredata.NewScopeFromObjectID(id)
+			s, err := r.riskManagement.GetScenario(ctx, scope, id)
+			if err != nil {
+				return nil, err
+			}
+			return types.NewRiskAssessmentScenario(s), nil
+		}
 	case coredata.ThirdPartyComplianceReportEntityType:
 		action = probo.ActionThirdPartyComplianceReportGet
 		loadNode = func(ctx context.Context, id gid.GID) (types.Node, error) {

pkg/server/api/console/v1/graphql/organization.graphql

@@ -291,6 +291,22 @@ type Organization implements Node {
 
     risksDocument: Document @goField(forceResolver: true)
 
+    riskAssessments(
+        first: Int
+        after: CursorKey
+        last: Int
+        before: CursorKey
+        orderBy: RiskAssessmentOrder
+    ): RiskAssessmentConnection! @goField(forceResolver: true)
+
+    riskAssessmentScenarios(
+        first: Int
+        after: CursorKey
+        last: Int
+        before: CursorKey
+        orderBy: RiskAssessmentScenarioOrder
+    ): RiskAssessmentScenarioConnection @goField(forceResolver: true)
+
     tasks(
         first: Int
         after: CursorKey

pkg/server/api/console/v1/graphql/risk.graphql

@@ -107,6 +107,14 @@ type Risk implements Node {
         orderBy: ObligationOrder
     ): ObligationConnection! @goField(forceResolver: true)
 
+    scenarios(
+        first: Int
+        after: CursorKey
+        last: Int
+        before: CursorKey
+        orderBy: RiskAssessmentScenarioOrder
+    ): RiskAssessmentScenarioConnection! @goField(forceResolver: true)
+
     createdAt: Datetime!
     updatedAt: Datetime!
 

pkg/server/api/console/v1/graphql/risk_assessment.graphql

@@ -0,0 +1,663 @@
+# Copyright (c) 2026 Probo Inc <hello@getprobo.com>.
+#
+# Permission to use, copy, modify, and/or distribute this software for any
+# purpose with or without fee is hereby granted, provided that the above
+# copyright notice and this permission notice appear in all copies.
+#
+# THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+# REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+# AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+# INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+# LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+# OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+# PERFORMANCE OF THIS SOFTWARE.
+
+# Enums
+
+enum RiskAssessmentOrderField
+    @goModel(
+        model: "go.probo.inc/probo/pkg/coredata.RiskAssessmentOrderField"
+    ) {
+    CREATED_AT
+        @goEnum(
+            value: "go.probo.inc/probo/pkg/coredata.RiskAssessmentOrderFieldCreatedAt"
+        )
+    NAME
+        @goEnum(
+            value: "go.probo.inc/probo/pkg/coredata.RiskAssessmentOrderFieldName"
+        )
+}
+
+enum RiskAssessmentScopeOrderField
+    @goModel(
+        model: "go.probo.inc/probo/pkg/coredata.RiskAssessmentScopeOrderField"
+    ) {
+    CREATED_AT
+        @goEnum(
+            value: "go.probo.inc/probo/pkg/coredata.RiskAssessmentScopeOrderFieldCreatedAt"
+        )
+    NAME
+        @goEnum(
+            value: "go.probo.inc/probo/pkg/coredata.RiskAssessmentScopeOrderFieldName"
+        )
+}
+
+enum RiskAssessmentNodeType
+    @goModel(
+        model: "go.probo.inc/probo/pkg/coredata.RiskAssessmentNodeType"
+    ) {
+    ENTITY
+        @goEnum(
+            value: "go.probo.inc/probo/pkg/coredata.RiskAssessmentNodeTypeEntity"
+        )
+    BOUNDARY
+        @goEnum(
+            value: "go.probo.inc/probo/pkg/coredata.RiskAssessmentNodeTypeBoundary"
+        )
+    ASSET
+        @goEnum(
+            value: "go.probo.inc/probo/pkg/coredata.RiskAssessmentNodeTypeAsset"
+        )
+    DATA
+        @goEnum(
+            value: "go.probo.inc/probo/pkg/coredata.RiskAssessmentNodeTypeData"
+        )
+}
+
+enum RiskAssessmentNodeOrderField
+    @goModel(
+        model: "go.probo.inc/probo/pkg/coredata.RiskAssessmentNodeOrderField"
+    ) {
+    CREATED_AT
+        @goEnum(
+            value: "go.probo.inc/probo/pkg/coredata.RiskAssessmentNodeOrderFieldCreatedAt"
+        )
+    NAME
+        @goEnum(
+            value: "go.probo.inc/probo/pkg/coredata.RiskAssessmentNodeOrderFieldName"
+        )
+}
+
+enum RiskAssessmentProcessOrderField
+    @goModel(
+        model: "go.probo.inc/probo/pkg/coredata.RiskAssessmentProcessOrderField"
+    ) {
+    CREATED_AT
+        @goEnum(
+            value: "go.probo.inc/probo/pkg/coredata.RiskAssessmentProcessOrderFieldCreatedAt"
+        )
+    NAME
+        @goEnum(
+            value: "go.probo.inc/probo/pkg/coredata.RiskAssessmentProcessOrderFieldName"
+        )
+}
+
+enum RiskAssessmentThreatOrderField
+    @goModel(
+        model: "go.probo.inc/probo/pkg/coredata.RiskAssessmentThreatOrderField"
+    ) {
+    CREATED_AT
+        @goEnum(
+            value: "go.probo.inc/probo/pkg/coredata.RiskAssessmentThreatOrderFieldCreatedAt"
+        )
+    NAME
+        @goEnum(
+            value: "go.probo.inc/probo/pkg/coredata.RiskAssessmentThreatOrderFieldName"
+        )
+}
+
+enum RiskAssessmentScenarioOrderField
+    @goModel(
+        model: "go.probo.inc/probo/pkg/coredata.RiskAssessmentScenarioOrderField"
+    ) {
+    CREATED_AT
+        @goEnum(
+            value: "go.probo.inc/probo/pkg/coredata.RiskAssessmentScenarioOrderFieldCreatedAt"
+        )
+    NAME
+        @goEnum(
+            value: "go.probo.inc/probo/pkg/coredata.RiskAssessmentScenarioOrderFieldName"
+        )
+}
+
+# Input types
+
+input RiskAssessmentOrder
+    @goModel(
+        model: "go.probo.inc/probo/pkg/server/api/console/v1/types.RiskAssessmentOrderBy"
+    ) {
+    direction: OrderDirection!
+    field: RiskAssessmentOrderField!
+}
+
+input RiskAssessmentScopeOrder
+    @goModel(
+        model: "go.probo.inc/probo/pkg/server/api/console/v1/types.RiskAssessmentScopeOrderBy"
+    ) {
+    direction: OrderDirection!
+    field: RiskAssessmentScopeOrderField!
+}
+
+input RiskAssessmentNodeOrder
+    @goModel(
+        model: "go.probo.inc/probo/pkg/server/api/console/v1/types.RiskAssessmentNodeOrderBy"
+    ) {
+    direction: OrderDirection!
+    field: RiskAssessmentNodeOrderField!
+}
+
+input RiskAssessmentProcessOrder
+    @goModel(
+        model: "go.probo.inc/probo/pkg/server/api/console/v1/types.RiskAssessmentProcessOrderBy"
+    ) {
+    direction: OrderDirection!
+    field: RiskAssessmentProcessOrderField!
+}
+
+input RiskAssessmentThreatOrder
+    @goModel(
+        model: "go.probo.inc/probo/pkg/server/api/console/v1/types.RiskAssessmentThreatOrderBy"
+    ) {
+    direction: OrderDirection!
+    field: RiskAssessmentThreatOrderField!
+}
+
+input RiskAssessmentScenarioOrder
+    @goModel(
+        model: "go.probo.inc/probo/pkg/server/api/console/v1/types.RiskAssessmentScenarioOrderBy"
+    ) {
+    direction: OrderDirection!
+    field: RiskAssessmentScenarioOrderField!
+}
+
+# Types
+
+type RiskAssessment implements Node {
+    id: ID!
+    name: String!
+    description: String
+    organization: Organization @goField(forceResolver: true)
+
+    scopes(
+        first: Int
+        after: CursorKey
+        last: Int
+        before: CursorKey
+        orderBy: RiskAssessmentScopeOrder
+    ): RiskAssessmentScopeConnection @goField(forceResolver: true)
+
+    createdAt: Datetime!
+    updatedAt: Datetime!
+    permission(action: String!): Boolean! @goField(forceResolver: true)
+}
+
+type RiskAssessmentScope implements Node {
+    id: ID!
+    riskAssessmentId: ID!
+    name: String!
+
+    nodes(
+        first: Int
+        after: CursorKey
+        last: Int
+        before: CursorKey
+        orderBy: RiskAssessmentNodeOrder
+    ): RiskAssessmentNodeConnection @goField(forceResolver: true)
+
+    processes(
+        first: Int
+        after: CursorKey
+        last: Int
+        before: CursorKey
+        orderBy: RiskAssessmentProcessOrder
+    ): RiskAssessmentProcessConnection @goField(forceResolver: true)
+
+    threats(
+        first: Int
+        after: CursorKey
+        last: Int
+        before: CursorKey
+        orderBy: RiskAssessmentThreatOrder
+    ): RiskAssessmentThreatConnection @goField(forceResolver: true)
+
+    scenarios(
+        first: Int
+        after: CursorKey
+        last: Int
+        before: CursorKey
+        orderBy: RiskAssessmentScenarioOrder
+    ): RiskAssessmentScenarioConnection @goField(forceResolver: true)
+
+    createdAt: Datetime!
+    updatedAt: Datetime!
+}
+
+type RiskAssessmentNode implements Node {
+    id: ID!
+    riskAssessmentScopeId: ID!
+    nodeType: RiskAssessmentNodeType!
+    name: String!
+    createdAt: Datetime!
+    updatedAt: Datetime!
+}
+
+type RiskAssessmentProcess implements Node {
+    id: ID!
+    riskAssessmentScopeId: ID!
+    sourceNodeId: ID!
+    targetNodeId: ID!
+    name: String!
+    createdAt: Datetime!
+    updatedAt: Datetime!
+}
+
+type RiskAssessmentThreat implements Node {
+    id: ID!
+    riskAssessmentScopeId: ID!
+    processId: ID!
+    name: String!
+    category: String!
+    createdAt: Datetime!
+    updatedAt: Datetime!
+}
+
+type RiskAssessmentScenario implements Node {
+    id: ID!
+    riskAssessmentScopeId: ID!
+    scope: RiskAssessmentScope @goField(forceResolver: true)
+    name: String!
+    description: String
+
+    threats(
+        first: Int
+        after: CursorKey
+        last: Int
+        before: CursorKey
+        orderBy: RiskAssessmentThreatOrder
+    ): RiskAssessmentThreatConnection @goField(forceResolver: true)
+
+    risks(
+        first: Int
+        after: CursorKey
+        last: Int
+        before: CursorKey
+        orderBy: RiskOrder
+    ): RiskConnection @goField(forceResolver: true)
+
+    createdAt: Datetime!
+    updatedAt: Datetime!
+}
+
+# Connections
+
+type RiskAssessmentConnection
+    @goModel(
+        model: "go.probo.inc/probo/pkg/server/api/console/v1/types.RiskAssessmentConnection"
+    ) {
+    totalCount: Int @goField(forceResolver: true)
+    edges: [RiskAssessmentConnectionEdge!]!
+    pageInfo: PageInfo!
+}
+
+type RiskAssessmentConnectionEdge {
+    cursor: CursorKey!
+    node: RiskAssessment!
+}
+
+type RiskAssessmentScopeConnection
+    @goModel(
+        model: "go.probo.inc/probo/pkg/server/api/console/v1/types.RiskAssessmentScopeConnection"
+    ) {
+    totalCount: Int @goField(forceResolver: true)
+    edges: [RiskAssessmentScopeConnectionEdge!]!
+    pageInfo: PageInfo!
+}
+
+type RiskAssessmentScopeConnectionEdge {
+    cursor: CursorKey!
+    node: RiskAssessmentScope!
+}
+
+type RiskAssessmentNodeConnection
+    @goModel(
+        model: "go.probo.inc/probo/pkg/server/api/console/v1/types.RiskAssessmentNodeConnection"
+    ) {
+    totalCount: Int @goField(forceResolver: true)
+    edges: [RiskAssessmentNodeConnectionEdge!]!
+    pageInfo: PageInfo!
+}
+
+type RiskAssessmentNodeConnectionEdge {
+    cursor: CursorKey!
+    node: RiskAssessmentNode!
+}
+
+type RiskAssessmentProcessConnection
+    @goModel(
+        model: "go.probo.inc/probo/pkg/server/api/console/v1/types.RiskAssessmentProcessConnection"
+    ) {
+    totalCount: Int @goField(forceResolver: true)
+    edges: [RiskAssessmentProcessConnectionEdge!]!
+    pageInfo: PageInfo!
+}
+
+type RiskAssessmentProcessConnectionEdge {
+    cursor: CursorKey!
+    node: RiskAssessmentProcess!
+}
+
+type RiskAssessmentThreatConnection
+    @goModel(
+        model: "go.probo.inc/probo/pkg/server/api/console/v1/types.RiskAssessmentThreatConnection"
+    ) {
+    totalCount: Int @goField(forceResolver: true)
+    edges: [RiskAssessmentThreatConnectionEdge!]!
+    pageInfo: PageInfo!
+}
+
+type RiskAssessmentThreatConnectionEdge {
+    cursor: CursorKey!
+    node: RiskAssessmentThreat!
+}
+
+type RiskAssessmentScenarioConnection
+    @goModel(
+        model: "go.probo.inc/probo/pkg/server/api/console/v1/types.RiskAssessmentScenarioConnection"
+    ) {
+    totalCount: Int @goField(forceResolver: true)
+    edges: [RiskAssessmentScenarioConnectionEdge!]!
+    pageInfo: PageInfo!
+}
+
+type RiskAssessmentScenarioConnectionEdge {
+    cursor: CursorKey!
+    node: RiskAssessmentScenario!
+}
+
+# Mutations
+
+extend type Mutation {
+    createRiskAssessment(
+        input: CreateRiskAssessmentInput!
+    ): CreateRiskAssessmentPayload!
+    updateRiskAssessment(
+        input: UpdateRiskAssessmentInput!
+    ): UpdateRiskAssessmentPayload!
+    deleteRiskAssessment(
+        input: DeleteRiskAssessmentInput!
+    ): DeleteRiskAssessmentPayload!
+
+    createRiskAssessmentScope(
+        input: CreateRiskAssessmentScopeInput!
+    ): CreateRiskAssessmentScopePayload!
+    updateRiskAssessmentScope(
+        input: UpdateRiskAssessmentScopeInput!
+    ): UpdateRiskAssessmentScopePayload!
+    deleteRiskAssessmentScope(
+        input: DeleteRiskAssessmentScopeInput!
+    ): DeleteRiskAssessmentScopePayload!
+
+    createRiskAssessmentNode(
+        input: CreateRiskAssessmentNodeInput!
+    ): CreateRiskAssessmentNodePayload!
+    updateRiskAssessmentNode(
+        input: UpdateRiskAssessmentNodeInput!
+    ): UpdateRiskAssessmentNodePayload!
+    deleteRiskAssessmentNode(
+        input: DeleteRiskAssessmentNodeInput!
+    ): DeleteRiskAssessmentNodePayload!
+
+    createRiskAssessmentProcess(
+        input: CreateRiskAssessmentProcessInput!
+    ): CreateRiskAssessmentProcessPayload!
+    updateRiskAssessmentProcess(
+        input: UpdateRiskAssessmentProcessInput!
+    ): UpdateRiskAssessmentProcessPayload!
+    deleteRiskAssessmentProcess(
+        input: DeleteRiskAssessmentProcessInput!
+    ): DeleteRiskAssessmentProcessPayload!
+
+    createRiskAssessmentThreat(
+        input: CreateRiskAssessmentThreatInput!
+    ): CreateRiskAssessmentThreatPayload!
+    updateRiskAssessmentThreat(
+        input: UpdateRiskAssessmentThreatInput!
+    ): UpdateRiskAssessmentThreatPayload!
+    deleteRiskAssessmentThreat(
+        input: DeleteRiskAssessmentThreatInput!
+    ): DeleteRiskAssessmentThreatPayload!
+
+    createRiskAssessmentScenario(
+        input: CreateRiskAssessmentScenarioInput!
+    ): CreateRiskAssessmentScenarioPayload!
+    updateRiskAssessmentScenario(
+        input: UpdateRiskAssessmentScenarioInput!
+    ): UpdateRiskAssessmentScenarioPayload!
+    deleteRiskAssessmentScenario(
+        input: DeleteRiskAssessmentScenarioInput!
+    ): DeleteRiskAssessmentScenarioPayload!
+
+    linkRiskAssessmentScenarioThreat(
+        input: LinkRiskAssessmentScenarioThreatInput!
+    ): LinkRiskAssessmentScenarioThreatPayload!
+    unlinkRiskAssessmentScenarioThreat(
+        input: UnlinkRiskAssessmentScenarioThreatInput!
+    ): UnlinkRiskAssessmentScenarioThreatPayload!
+
+    linkRiskAssessmentScenarioRisk(
+        input: LinkRiskAssessmentScenarioRiskInput!
+    ): LinkRiskAssessmentScenarioRiskPayload!
+    unlinkRiskAssessmentScenarioRisk(
+        input: UnlinkRiskAssessmentScenarioRiskInput!
+    ): UnlinkRiskAssessmentScenarioRiskPayload!
+}
+
+# Mutation inputs & payloads
+
+input CreateRiskAssessmentInput {
+    organizationId: ID!
+    name: String!
+    description: String
+}
+
+input UpdateRiskAssessmentInput {
+    id: ID!
+    name: String
+    description: String @goField(omittable: true)
+}
+
+input DeleteRiskAssessmentInput {
+    riskAssessmentId: ID!
+}
+
+type CreateRiskAssessmentPayload {
+    riskAssessmentEdge: RiskAssessmentConnectionEdge!
+}
+
+type UpdateRiskAssessmentPayload {
+    riskAssessment: RiskAssessment!
+}
+
+type DeleteRiskAssessmentPayload {
+    deletedRiskAssessmentId: ID!
+}
+
+input CreateRiskAssessmentScopeInput {
+    riskAssessmentId: ID!
+    name: String!
+}
+
+input UpdateRiskAssessmentScopeInput {
+    id: ID!
+    name: String
+}
+
+input DeleteRiskAssessmentScopeInput {
+    riskAssessmentScopeId: ID!
+}
+
+type CreateRiskAssessmentScopePayload {
+    riskAssessmentScopeEdge: RiskAssessmentScopeConnectionEdge!
+}
+
+type UpdateRiskAssessmentScopePayload {
+    riskAssessmentScope: RiskAssessmentScope!
+}
+
+type DeleteRiskAssessmentScopePayload {
+    deletedRiskAssessmentScopeId: ID!
+}
+
+input CreateRiskAssessmentNodeInput {
+    riskAssessmentScopeId: ID!
+    nodeType: RiskAssessmentNodeType!
+    name: String!
+}
+
+input UpdateRiskAssessmentNodeInput {
+    id: ID!
+    nodeType: RiskAssessmentNodeType
+    name: String
+}
+
+input DeleteRiskAssessmentNodeInput {
+    riskAssessmentNodeId: ID!
+}
+
+type CreateRiskAssessmentNodePayload {
+    riskAssessmentNodeEdge: RiskAssessmentNodeConnectionEdge!
+}
+
+type UpdateRiskAssessmentNodePayload {
+    riskAssessmentNode: RiskAssessmentNode!
+}
+
+type DeleteRiskAssessmentNodePayload {
+    deletedRiskAssessmentNodeId: ID!
+}
+
+input CreateRiskAssessmentProcessInput {
+    riskAssessmentScopeId: ID!
+    sourceNodeId: ID!
+    targetNodeId: ID!
+    name: String!
+}
+
+input UpdateRiskAssessmentProcessInput {
+    id: ID!
+    sourceNodeId: ID
+    targetNodeId: ID
+    name: String
+}
+
+input DeleteRiskAssessmentProcessInput {
+    riskAssessmentProcessId: ID!
+}
+
+type CreateRiskAssessmentProcessPayload {
+    riskAssessmentProcessEdge: RiskAssessmentProcessConnectionEdge!
+}
+
+type UpdateRiskAssessmentProcessPayload {
+    riskAssessmentProcess: RiskAssessmentProcess!
+}
+
+type DeleteRiskAssessmentProcessPayload {
+    deletedRiskAssessmentProcessId: ID!
+}
+
+input CreateRiskAssessmentThreatInput {
+    riskAssessmentScopeId: ID!
+    processId: ID!
+    name: String!
+    category: String!
+}
+
+input UpdateRiskAssessmentThreatInput {
+    id: ID!
+    processId: ID
+    name: String
+    category: String
+}
+
+input DeleteRiskAssessmentThreatInput {
+    riskAssessmentThreatId: ID!
+}
+
+type CreateRiskAssessmentThreatPayload {
+    riskAssessmentThreatEdge: RiskAssessmentThreatConnectionEdge!
+}
+
+type UpdateRiskAssessmentThreatPayload {
+    riskAssessmentThreat: RiskAssessmentThreat!
+}
+
+type DeleteRiskAssessmentThreatPayload {
+    deletedRiskAssessmentThreatId: ID!
+}
+
+input CreateRiskAssessmentScenarioInput {
+    riskAssessmentScopeId: ID!
+    name: String!
+    description: String
+}
+
+input UpdateRiskAssessmentScenarioInput {
+    id: ID!
+    name: String
+    description: String @goField(omittable: true)
+}
+
+input DeleteRiskAssessmentScenarioInput {
+    riskAssessmentScenarioId: ID!
+}
+
+type CreateRiskAssessmentScenarioPayload {
+    riskAssessmentScenarioEdge: RiskAssessmentScenarioConnectionEdge!
+}
+
+type UpdateRiskAssessmentScenarioPayload {
+    riskAssessmentScenario: RiskAssessmentScenario!
+}
+
+type DeleteRiskAssessmentScenarioPayload {
+    deletedRiskAssessmentScenarioId: ID!
+}
+
+input LinkRiskAssessmentScenarioThreatInput {
+    riskAssessmentScenarioId: ID!
+    threatId: ID!
+}
+
+type LinkRiskAssessmentScenarioThreatPayload {
+    riskAssessmentScenario: RiskAssessmentScenario!
+}
+
+input UnlinkRiskAssessmentScenarioThreatInput {
+    riskAssessmentScenarioId: ID!
+    threatId: ID!
+}
+
+type UnlinkRiskAssessmentScenarioThreatPayload {
+    riskAssessmentScenario: RiskAssessmentScenario!
+}
+
+input LinkRiskAssessmentScenarioRiskInput {
+    riskAssessmentScenarioId: ID!
+    riskId: ID!
+}
+
+type LinkRiskAssessmentScenarioRiskPayload {
+    riskAssessmentScenario: RiskAssessmentScenario!
+    riskAssessmentScenarioEdge: RiskAssessmentScenarioConnectionEdge!
+}
+
+input UnlinkRiskAssessmentScenarioRiskInput {
+    riskAssessmentScenarioId: ID!
+    riskId: ID!
+}
+
+type UnlinkRiskAssessmentScenarioRiskPayload {
+    riskAssessmentScenario: RiskAssessmentScenario!
+    deletedRiskAssessmentScenarioId: ID!
+}

pkg/server/api/console/v1/graphql_handler.go

@@ -25,6 +25,7 @@ import (
 	"go.probo.inc/probo/pkg/iam"
 	"go.probo.inc/probo/pkg/mailman"
 	"go.probo.inc/probo/pkg/probo"
+	"go.probo.inc/probo/pkg/riskmanagement"
 	"go.probo.inc/probo/pkg/server/api/authz"
 	"go.probo.inc/probo/pkg/server/api/console/v1/schema"
 	"go.probo.inc/probo/pkg/server/gqlutils"
@@ -42,6 +43,7 @@ func NewGraphQLHandler(
 	customDomainCname string,
 	logger *log.Logger,
 	thirdPartySvc *thirdparty.Service,
+	riskManagementSvc *riskmanagement.Service,
 ) http.Handler {
 	config := schema.Config{
 		Resolvers: &Resolver{
@@ -53,6 +55,7 @@ func NewGraphQLHandler(
 			mailman:           mailmanSvc,
 			cookieBanner:      cookieBannerSvc,
 			connectorRegistry: connectorRegistry,
+			riskManagement:    riskManagementSvc,
 			thirdParty:        thirdPartySvc,
 			customDomainCname: customDomainCname,
 			logger:            logger,

pkg/server/api/console/v1/organization_resolvers.go

@@ -1070,6 +1070,66 @@ func (r *organizationResolver) RisksDocument(ctx context.Context, obj *types.Org
 	return types.NewDocument(document), nil
 }
 
+// RiskAssessments is the resolver for the riskAssessments field.
+func (r *organizationResolver) RiskAssessments(ctx context.Context, obj *types.Organization, first *int, after *page.CursorKey, last *int, before *page.CursorKey, orderBy *types.RiskAssessmentOrderBy) (*types.RiskAssessmentConnection, error) {
+	if err := r.authorize(ctx, obj.ID, probo.ActionRiskAssessmentList); err != nil {
+		return nil, err
+	}
+
+	scope := coredata.NewScopeFromObjectID(obj.ID)
+
+	pageOrderBy := page.OrderBy[coredata.RiskAssessmentOrderField]{
+		Field:     coredata.RiskAssessmentOrderFieldCreatedAt,
+		Direction: page.OrderDirectionDesc,
+	}
+	if orderBy != nil {
+		pageOrderBy = page.OrderBy[coredata.RiskAssessmentOrderField]{
+			Field:     orderBy.Field,
+			Direction: orderBy.Direction,
+		}
+	}
+
+	cursor := types.NewCursor(first, after, last, before, pageOrderBy)
+
+	p, err := r.riskManagement.ListForOrganizationID(ctx, scope, obj.ID, cursor)
+	if err != nil {
+		r.logger.ErrorCtx(ctx, "cannot list risk assessments", log.Error(err))
+		return nil, gqlutils.Internal(ctx)
+	}
+
+	return types.NewRiskAssessmentConnection(p, r, obj.ID), nil
+}
+
+// RiskAssessmentScenarios is the resolver for the riskAssessmentScenarios field.
+func (r *organizationResolver) RiskAssessmentScenarios(ctx context.Context, obj *types.Organization, first *int, after *page.CursorKey, last *int, before *page.CursorKey, orderBy *types.RiskAssessmentScenarioOrderBy) (*types.RiskAssessmentScenarioConnection, error) {
+	if err := r.authorize(ctx, obj.ID, probo.ActionRiskAssessmentScenarioList); err != nil {
+		return nil, err
+	}
+
+	scope := coredata.NewScopeFromObjectID(obj.ID)
+
+	pageOrderBy := page.OrderBy[coredata.RiskAssessmentScenarioOrderField]{
+		Field:     coredata.RiskAssessmentScenarioOrderFieldCreatedAt,
+		Direction: page.OrderDirectionDesc,
+	}
+	if orderBy != nil {
+		pageOrderBy = page.OrderBy[coredata.RiskAssessmentScenarioOrderField]{
+			Field:     orderBy.Field,
+			Direction: orderBy.Direction,
+		}
+	}
+
+	cursor := types.NewCursor(first, after, last, before, pageOrderBy)
+
+	p, err := r.riskManagement.ListScenariosForOrganizationID(ctx, scope, obj.ID, cursor)
+	if err != nil {
+		r.logger.ErrorCtx(ctx, "cannot list risk scenarios", log.Error(err))
+		return nil, gqlutils.Internal(ctx)
+	}
+
+	return types.NewRiskAssessmentScenarioConnection(p, r, obj.ID), nil
+}
+
 // Tasks is the resolver for the tasks field.
 func (r *organizationResolver) Tasks(ctx context.Context, obj *types.Organization, first *int, after *page.CursorKey, last *int, before *page.CursorKey, orderBy *types.TaskOrderBy) (*types.TaskConnection, error) {
 	if err := r.authorize(ctx, obj.ID, probo.ActionTaskList); err != nil {

pkg/server/api/console/v1/resolver.go

@@ -35,6 +35,7 @@ import (
 	"go.probo.inc/probo/pkg/iam"
 	"go.probo.inc/probo/pkg/mailman"
 	"go.probo.inc/probo/pkg/probo"
+	"go.probo.inc/probo/pkg/riskmanagement"
 	"go.probo.inc/probo/pkg/saferedirect"
 	"go.probo.inc/probo/pkg/securecookie"
 	"go.probo.inc/probo/pkg/server/api/authn"
@@ -54,6 +55,7 @@ type (
 		mailman           *mailman.Service
 		cookieBanner      *cookiebanner.Service
 		connectorRegistry *connector.ConnectorRegistry
+		riskManagement    *riskmanagement.Service
 		thirdParty        *thirdparty.Service
 		logger            *log.Logger
 		customDomainCname string
@@ -74,6 +76,7 @@ func NewMux(
 	baseURL *baseurl.BaseURL,
 	customDomainCname string,
 	thirdPartySvc *thirdparty.Service,
+	riskManagementSvc *riskmanagement.Service,
 ) *chi.Mux {
 	r := chi.NewMux()
 
@@ -90,6 +93,7 @@ func NewMux(
 		customDomainCname,
 		logger,
 		thirdPartySvc,
+		riskManagementSvc,
 	)
 
 	r.Group(func(r chi.Router) {

pkg/server/api/console/v1/risk_assessment_resolvers.go

@@ -0,0 +1,947 @@
+package console_v1
+
+// This file will be automatically regenerated based on the schema, any resolver
+// implementations
+// will be copied through when generating and any unknown code will be moved to the end.
+// Code generated by github.com/99designs/gqlgen version v0.17.90
+
+import (
+	"context"
+	"errors"
+
+	"github.com/vikstrous/dataloadgen"
+	"go.gearno.de/kit/log"
+	"go.probo.inc/probo/pkg/coredata"
+	"go.probo.inc/probo/pkg/page"
+	"go.probo.inc/probo/pkg/probo"
+	"go.probo.inc/probo/pkg/riskmanagement"
+	"go.probo.inc/probo/pkg/server/api/console/v1/dataloader"
+	"go.probo.inc/probo/pkg/server/api/console/v1/schema"
+	"go.probo.inc/probo/pkg/server/api/console/v1/types"
+	"go.probo.inc/probo/pkg/server/gqlutils"
+	"go.probo.inc/probo/pkg/validator"
+)
+
+// CreateRiskAssessment is the resolver for the createRiskAssessment field.
+func (r *mutationResolver) CreateRiskAssessment(ctx context.Context, input types.CreateRiskAssessmentInput) (*types.CreateRiskAssessmentPayload, error) {
+	if err := r.authorize(ctx, input.OrganizationID, probo.ActionRiskAssessmentCreate); err != nil {
+		return nil, err
+	}
+	scope := coredata.NewScopeFromObjectID(input.OrganizationID)
+	ra, err := r.riskManagement.Create(
+		ctx,
+		scope,
+		riskmanagement.CreateRiskAssessmentRequest{
+			OrganizationID: input.OrganizationID,
+			Name:           input.Name,
+			Description:    input.Description,
+		},
+	)
+	if err != nil {
+		if errors.Is(err, coredata.ErrResourceAlreadyExists) {
+			return nil, gqlutils.Conflict(ctx, err)
+		}
+		if validationErrors, ok := errors.AsType[validator.ValidationErrors](err); ok {
+			return nil, gqlutils.InvalidValidationErrors(ctx, validationErrors)
+		}
+		r.logger.ErrorCtx(ctx, "cannot create risk assessment", log.Error(err))
+		return nil, gqlutils.Internal(ctx)
+	}
+	return &types.CreateRiskAssessmentPayload{
+		RiskAssessmentEdge: types.NewRiskAssessmentConnectionEdge(ra, coredata.RiskAssessmentOrderFieldCreatedAt),
+	}, nil
+}
+
+// UpdateRiskAssessment is the resolver for the updateRiskAssessment field.
+func (r *mutationResolver) UpdateRiskAssessment(ctx context.Context, input types.UpdateRiskAssessmentInput) (*types.UpdateRiskAssessmentPayload, error) {
+	if err := r.authorize(ctx, input.ID, probo.ActionRiskAssessmentUpdate); err != nil {
+		return nil, err
+	}
+	scope := coredata.NewScopeFromObjectID(input.ID)
+	ra, err := r.riskManagement.Update(
+		ctx,
+		scope,
+		riskmanagement.UpdateRiskAssessmentRequest{
+			ID:          input.ID,
+			Name:        input.Name,
+			Description: gqlutils.UnwrapOmittable(input.Description),
+		},
+	)
+	if err != nil {
+		if validationErrors, ok := errors.AsType[validator.ValidationErrors](err); ok {
+			return nil, gqlutils.InvalidValidationErrors(ctx, validationErrors)
+		}
+		r.logger.ErrorCtx(ctx, "cannot update risk assessment", log.Error(err))
+		return nil, gqlutils.Internal(ctx)
+	}
+	return &types.UpdateRiskAssessmentPayload{RiskAssessment: types.NewRiskAssessment(ra)}, nil
+}
+
+// DeleteRiskAssessment is the resolver for the deleteRiskAssessment field.
+func (r *mutationResolver) DeleteRiskAssessment(ctx context.Context, input types.DeleteRiskAssessmentInput) (*types.DeleteRiskAssessmentPayload, error) {
+	if err := r.authorize(ctx, input.RiskAssessmentID, probo.ActionRiskAssessmentDelete); err != nil {
+		return nil, err
+	}
+	scope := coredata.NewScopeFromObjectID(input.RiskAssessmentID)
+	if err := r.riskManagement.Delete(ctx, scope, input.RiskAssessmentID); err != nil {
+		if errors.Is(err, coredata.ErrResourceNotFound) {
+			return nil, gqlutils.NotFound(ctx, err)
+		}
+		r.logger.ErrorCtx(ctx, "cannot delete risk assessment", log.Error(err))
+		return nil, gqlutils.Internal(ctx)
+	}
+	return &types.DeleteRiskAssessmentPayload{DeletedRiskAssessmentID: input.RiskAssessmentID}, nil
+}
+
+// CreateRiskAssessmentScope is the resolver for the createRiskAssessmentScope field.
+func (r *mutationResolver) CreateRiskAssessmentScope(ctx context.Context, input types.CreateRiskAssessmentScopeInput) (*types.CreateRiskAssessmentScopePayload, error) {
+	if err := r.authorize(ctx, input.RiskAssessmentID, probo.ActionRiskAssessmentScopeCreate); err != nil {
+		return nil, err
+	}
+	scope := coredata.NewScopeFromObjectID(input.RiskAssessmentID)
+	raScope, err := r.riskManagement.CreateScope(
+		ctx,
+		scope,
+		riskmanagement.CreateRiskAssessmentScopeRequest{
+			RiskAssessmentID: input.RiskAssessmentID,
+			Name:             input.Name,
+		},
+	)
+	if err != nil {
+		if errors.Is(err, coredata.ErrResourceAlreadyExists) {
+			return nil, gqlutils.Conflict(ctx, err)
+		}
+		if validationErrors, ok := errors.AsType[validator.ValidationErrors](err); ok {
+			return nil, gqlutils.InvalidValidationErrors(ctx, validationErrors)
+		}
+		r.logger.ErrorCtx(ctx, "cannot create risk assessment scope", log.Error(err))
+		return nil, gqlutils.Internal(ctx)
+	}
+	return &types.CreateRiskAssessmentScopePayload{
+		RiskAssessmentScopeEdge: types.NewRiskAssessmentScopeConnectionEdge(raScope, coredata.RiskAssessmentScopeOrderFieldCreatedAt),
+	}, nil
+}
+
+// UpdateRiskAssessmentScope is the resolver for the updateRiskAssessmentScope field.
+func (r *mutationResolver) UpdateRiskAssessmentScope(ctx context.Context, input types.UpdateRiskAssessmentScopeInput) (*types.UpdateRiskAssessmentScopePayload, error) {
+	if err := r.authorize(ctx, input.ID, probo.ActionRiskAssessmentScopeUpdate); err != nil {
+		return nil, err
+	}
+	scope := coredata.NewScopeFromObjectID(input.ID)
+	raScope, err := r.riskManagement.UpdateScope(
+		ctx,
+		scope,
+		riskmanagement.UpdateRiskAssessmentScopeRequest{
+			ID:   input.ID,
+			Name: input.Name,
+		},
+	)
+	if err != nil {
+		if validationErrors, ok := errors.AsType[validator.ValidationErrors](err); ok {
+			return nil, gqlutils.InvalidValidationErrors(ctx, validationErrors)
+		}
+		r.logger.ErrorCtx(ctx, "cannot update risk assessment scope", log.Error(err))
+		return nil, gqlutils.Internal(ctx)
+	}
+	return &types.UpdateRiskAssessmentScopePayload{RiskAssessmentScope: types.NewRiskAssessmentScope(raScope)}, nil
+}
+
+// DeleteRiskAssessmentScope is the resolver for the deleteRiskAssessmentScope field.
+func (r *mutationResolver) DeleteRiskAssessmentScope(ctx context.Context, input types.DeleteRiskAssessmentScopeInput) (*types.DeleteRiskAssessmentScopePayload, error) {
+	if err := r.authorize(ctx, input.RiskAssessmentScopeID, probo.ActionRiskAssessmentScopeDelete); err != nil {
+		return nil, err
+	}
+	scope := coredata.NewScopeFromObjectID(input.RiskAssessmentScopeID)
+	if err := r.riskManagement.DeleteScope(ctx, scope, input.RiskAssessmentScopeID); err != nil {
+		if errors.Is(err, coredata.ErrResourceNotFound) {
+			return nil, gqlutils.NotFound(ctx, err)
+		}
+		r.logger.ErrorCtx(ctx, "cannot delete risk assessment scope", log.Error(err))
+		return nil, gqlutils.Internal(ctx)
+	}
+	return &types.DeleteRiskAssessmentScopePayload{DeletedRiskAssessmentScopeID: input.RiskAssessmentScopeID}, nil
+}
+
+// CreateRiskAssessmentNode is the resolver for the createRiskAssessmentNode field.
+func (r *mutationResolver) CreateRiskAssessmentNode(ctx context.Context, input types.CreateRiskAssessmentNodeInput) (*types.CreateRiskAssessmentNodePayload, error) {
+	if err := r.authorize(ctx, input.RiskAssessmentScopeID, probo.ActionRiskAssessmentNodeCreate); err != nil {
+		return nil, err
+	}
+	scope := coredata.NewScopeFromObjectID(input.RiskAssessmentScopeID)
+	node, err := r.riskManagement.CreateNode(
+		ctx,
+		scope,
+		riskmanagement.CreateRiskAssessmentNodeRequest{
+			RiskAssessmentScopeID: input.RiskAssessmentScopeID,
+			NodeType:              input.NodeType,
+			Name:                  input.Name,
+		},
+	)
+	if err != nil {
+		if errors.Is(err, coredata.ErrResourceAlreadyExists) {
+			return nil, gqlutils.Conflict(ctx, err)
+		}
+		if validationErrors, ok := errors.AsType[validator.ValidationErrors](err); ok {
+			return nil, gqlutils.InvalidValidationErrors(ctx, validationErrors)
+		}
+		r.logger.ErrorCtx(ctx, "cannot create risk assessment node", log.Error(err))
+		return nil, gqlutils.Internal(ctx)
+	}
+	return &types.CreateRiskAssessmentNodePayload{
+		RiskAssessmentNodeEdge: &types.RiskAssessmentNodeConnectionEdge{
+			Cursor: node.CursorKey(coredata.RiskAssessmentNodeOrderFieldCreatedAt),
+			Node:   types.NewRiskAssessmentNode(node),
+		},
+	}, nil
+}
+
+// UpdateRiskAssessmentNode is the resolver for the updateRiskAssessmentNode field.
+func (r *mutationResolver) UpdateRiskAssessmentNode(ctx context.Context, input types.UpdateRiskAssessmentNodeInput) (*types.UpdateRiskAssessmentNodePayload, error) {
+	if err := r.authorize(ctx, input.ID, probo.ActionRiskAssessmentNodeUpdate); err != nil {
+		return nil, err
+	}
+	scope := coredata.NewScopeFromObjectID(input.ID)
+	node, err := r.riskManagement.UpdateNode(
+		ctx,
+		scope,
+		riskmanagement.UpdateRiskAssessmentNodeRequest{
+			ID:       input.ID,
+			NodeType: input.NodeType,
+			Name:     input.Name,
+		},
+	)
+	if err != nil {
+		if validationErrors, ok := errors.AsType[validator.ValidationErrors](err); ok {
+			return nil, gqlutils.InvalidValidationErrors(ctx, validationErrors)
+		}
+		r.logger.ErrorCtx(ctx, "cannot update risk assessment node", log.Error(err))
+		return nil, gqlutils.Internal(ctx)
+	}
+	return &types.UpdateRiskAssessmentNodePayload{RiskAssessmentNode: types.NewRiskAssessmentNode(node)}, nil
+}
+
+// DeleteRiskAssessmentNode is the resolver for the deleteRiskAssessmentNode field.
+func (r *mutationResolver) DeleteRiskAssessmentNode(ctx context.Context, input types.DeleteRiskAssessmentNodeInput) (*types.DeleteRiskAssessmentNodePayload, error) {
+	if err := r.authorize(ctx, input.RiskAssessmentNodeID, probo.ActionRiskAssessmentNodeDelete); err != nil {
+		return nil, err
+	}
+	scope := coredata.NewScopeFromObjectID(input.RiskAssessmentNodeID)
+	if err := r.riskManagement.DeleteNode(ctx, scope, input.RiskAssessmentNodeID); err != nil {
+		if errors.Is(err, coredata.ErrResourceNotFound) {
+			return nil, gqlutils.NotFound(ctx, err)
+		}
+		r.logger.ErrorCtx(ctx, "cannot delete risk assessment node", log.Error(err))
+		return nil, gqlutils.Internal(ctx)
+	}
+	return &types.DeleteRiskAssessmentNodePayload{DeletedRiskAssessmentNodeID: input.RiskAssessmentNodeID}, nil
+}
+
+// CreateRiskAssessmentProcess is the resolver for the createRiskAssessmentProcess field.
+func (r *mutationResolver) CreateRiskAssessmentProcess(ctx context.Context, input types.CreateRiskAssessmentProcessInput) (*types.CreateRiskAssessmentProcessPayload, error) {
+	if err := r.authorize(ctx, input.RiskAssessmentScopeID, probo.ActionRiskAssessmentProcessCreate); err != nil {
+		return nil, err
+	}
+	scope := coredata.NewScopeFromObjectID(input.RiskAssessmentScopeID)
+	process, err := r.riskManagement.CreateProcess(
+		ctx,
+		scope,
+		riskmanagement.CreateRiskAssessmentProcessRequest{
+			RiskAssessmentScopeID: input.RiskAssessmentScopeID,
+			SourceNodeID:          input.SourceNodeID,
+			TargetNodeID:          input.TargetNodeID,
+			Name:                  input.Name,
+		},
+	)
+	if err != nil {
+		if errors.Is(err, coredata.ErrResourceAlreadyExists) {
+			return nil, gqlutils.Conflict(ctx, err)
+		}
+		if validationErrors, ok := errors.AsType[validator.ValidationErrors](err); ok {
+			return nil, gqlutils.InvalidValidationErrors(ctx, validationErrors)
+		}
+		r.logger.ErrorCtx(ctx, "cannot create risk assessment process", log.Error(err))
+		return nil, gqlutils.Internal(ctx)
+	}
+	return &types.CreateRiskAssessmentProcessPayload{
+		RiskAssessmentProcessEdge: &types.RiskAssessmentProcessConnectionEdge{
+			Cursor: process.CursorKey(coredata.RiskAssessmentProcessOrderFieldCreatedAt),
+			Node:   types.NewRiskAssessmentProcess(process),
+		},
+	}, nil
+}
+
+// UpdateRiskAssessmentProcess is the resolver for the updateRiskAssessmentProcess field.
+func (r *mutationResolver) UpdateRiskAssessmentProcess(ctx context.Context, input types.UpdateRiskAssessmentProcessInput) (*types.UpdateRiskAssessmentProcessPayload, error) {
+	if err := r.authorize(ctx, input.ID, probo.ActionRiskAssessmentProcessUpdate); err != nil {
+		return nil, err
+	}
+	scope := coredata.NewScopeFromObjectID(input.ID)
+	process, err := r.riskManagement.UpdateProcess(
+		ctx,
+		scope,
+		riskmanagement.UpdateRiskAssessmentProcessRequest{
+			ID:           input.ID,
+			SourceNodeID: input.SourceNodeID,
+			TargetNodeID: input.TargetNodeID,
+			Name:         input.Name,
+		},
+	)
+	if err != nil {
+		if validationErrors, ok := errors.AsType[validator.ValidationErrors](err); ok {
+			return nil, gqlutils.InvalidValidationErrors(ctx, validationErrors)
+		}
+		r.logger.ErrorCtx(ctx, "cannot update risk assessment process", log.Error(err))
+		return nil, gqlutils.Internal(ctx)
+	}
+	return &types.UpdateRiskAssessmentProcessPayload{RiskAssessmentProcess: types.NewRiskAssessmentProcess(process)}, nil
+}
+
+// DeleteRiskAssessmentProcess is the resolver for the deleteRiskAssessmentProcess field.
+func (r *mutationResolver) DeleteRiskAssessmentProcess(ctx context.Context, input types.DeleteRiskAssessmentProcessInput) (*types.DeleteRiskAssessmentProcessPayload, error) {
+	if err := r.authorize(ctx, input.RiskAssessmentProcessID, probo.ActionRiskAssessmentProcessDelete); err != nil {
+		return nil, err
+	}
+	scope := coredata.NewScopeFromObjectID(input.RiskAssessmentProcessID)
+	if err := r.riskManagement.DeleteProcess(ctx, scope, input.RiskAssessmentProcessID); err != nil {
+		if errors.Is(err, coredata.ErrResourceNotFound) {
+			return nil, gqlutils.NotFound(ctx, err)
+		}
+		r.logger.ErrorCtx(ctx, "cannot delete risk assessment process", log.Error(err))
+		return nil, gqlutils.Internal(ctx)
+	}
+	return &types.DeleteRiskAssessmentProcessPayload{DeletedRiskAssessmentProcessID: input.RiskAssessmentProcessID}, nil
+}
+
+// CreateRiskAssessmentThreat is the resolver for the createRiskAssessmentThreat field.
+func (r *mutationResolver) CreateRiskAssessmentThreat(ctx context.Context, input types.CreateRiskAssessmentThreatInput) (*types.CreateRiskAssessmentThreatPayload, error) {
+	if err := r.authorize(ctx, input.RiskAssessmentScopeID, probo.ActionRiskAssessmentThreatCreate); err != nil {
+		return nil, err
+	}
+	scope := coredata.NewScopeFromObjectID(input.RiskAssessmentScopeID)
+	threat, err := r.riskManagement.CreateThreat(
+		ctx,
+		scope,
+		riskmanagement.CreateRiskAssessmentThreatRequest{
+			RiskAssessmentScopeID: input.RiskAssessmentScopeID,
+			ProcessID:             input.ProcessID,
+			Name:                  input.Name,
+			Category:              input.Category,
+		},
+	)
+	if err != nil {
+		if errors.Is(err, coredata.ErrResourceAlreadyExists) {
+			return nil, gqlutils.Conflict(ctx, err)
+		}
+		if validationErrors, ok := errors.AsType[validator.ValidationErrors](err); ok {
+			return nil, gqlutils.InvalidValidationErrors(ctx, validationErrors)
+		}
+		r.logger.ErrorCtx(ctx, "cannot create risk threat", log.Error(err))
+		return nil, gqlutils.Internal(ctx)
+	}
+	return &types.CreateRiskAssessmentThreatPayload{
+		RiskAssessmentThreatEdge: &types.RiskAssessmentThreatConnectionEdge{
+			Cursor: threat.CursorKey(coredata.RiskAssessmentThreatOrderFieldCreatedAt),
+			Node:   types.NewRiskAssessmentThreat(threat),
+		},
+	}, nil
+}
+
+// UpdateRiskAssessmentThreat is the resolver for the updateRiskAssessmentThreat field.
+func (r *mutationResolver) UpdateRiskAssessmentThreat(ctx context.Context, input types.UpdateRiskAssessmentThreatInput) (*types.UpdateRiskAssessmentThreatPayload, error) {
+	if err := r.authorize(ctx, input.ID, probo.ActionRiskAssessmentThreatUpdate); err != nil {
+		return nil, err
+	}
+	scope := coredata.NewScopeFromObjectID(input.ID)
+	threat, err := r.riskManagement.UpdateThreat(
+		ctx,
+		scope,
+		riskmanagement.UpdateRiskAssessmentThreatRequest{
+			ID:        input.ID,
+			ProcessID: input.ProcessID,
+			Name:      input.Name,
+			Category:  input.Category,
+		},
+	)
+	if err != nil {
+		if validationErrors, ok := errors.AsType[validator.ValidationErrors](err); ok {
+			return nil, gqlutils.InvalidValidationErrors(ctx, validationErrors)
+		}
+		r.logger.ErrorCtx(ctx, "cannot update risk threat", log.Error(err))
+		return nil, gqlutils.Internal(ctx)
+	}
+	return &types.UpdateRiskAssessmentThreatPayload{RiskAssessmentThreat: types.NewRiskAssessmentThreat(threat)}, nil
+}
+
+// DeleteRiskAssessmentThreat is the resolver for the deleteRiskAssessmentThreat field.
+func (r *mutationResolver) DeleteRiskAssessmentThreat(ctx context.Context, input types.DeleteRiskAssessmentThreatInput) (*types.DeleteRiskAssessmentThreatPayload, error) {
+	if err := r.authorize(ctx, input.RiskAssessmentThreatID, probo.ActionRiskAssessmentThreatDelete); err != nil {
+		return nil, err
+	}
+	scope := coredata.NewScopeFromObjectID(input.RiskAssessmentThreatID)
+	if err := r.riskManagement.DeleteThreat(ctx, scope, input.RiskAssessmentThreatID); err != nil {
+		if errors.Is(err, coredata.ErrResourceNotFound) {
+			return nil, gqlutils.NotFound(ctx, err)
+		}
+		r.logger.ErrorCtx(ctx, "cannot delete risk threat", log.Error(err))
+		return nil, gqlutils.Internal(ctx)
+	}
+	return &types.DeleteRiskAssessmentThreatPayload{DeletedRiskAssessmentThreatID: input.RiskAssessmentThreatID}, nil
+}
+
+// CreateRiskAssessmentScenario is the resolver for the createRiskAssessmentScenario field.
+func (r *mutationResolver) CreateRiskAssessmentScenario(ctx context.Context, input types.CreateRiskAssessmentScenarioInput) (*types.CreateRiskAssessmentScenarioPayload, error) {
+	if err := r.authorize(ctx, input.RiskAssessmentScopeID, probo.ActionRiskAssessmentScenarioCreate); err != nil {
+		return nil, err
+	}
+	scope := coredata.NewScopeFromObjectID(input.RiskAssessmentScopeID)
+	scenario, err := r.riskManagement.CreateScenario(
+		ctx,
+		scope,
+		riskmanagement.CreateRiskAssessmentScenarioRequest{
+			RiskAssessmentScopeID: input.RiskAssessmentScopeID,
+			Name:                  input.Name,
+			Description:           input.Description,
+		},
+	)
+	if err != nil {
+		if errors.Is(err, coredata.ErrResourceAlreadyExists) {
+			return nil, gqlutils.Conflict(ctx, err)
+		}
+		if validationErrors, ok := errors.AsType[validator.ValidationErrors](err); ok {
+			return nil, gqlutils.InvalidValidationErrors(ctx, validationErrors)
+		}
+		r.logger.ErrorCtx(ctx, "cannot create risk scenario", log.Error(err))
+		return nil, gqlutils.Internal(ctx)
+	}
+	return &types.CreateRiskAssessmentScenarioPayload{
+		RiskAssessmentScenarioEdge: &types.RiskAssessmentScenarioConnectionEdge{
+			Cursor: scenario.CursorKey(coredata.RiskAssessmentScenarioOrderFieldCreatedAt),
+			Node:   types.NewRiskAssessmentScenario(scenario),
+		},
+	}, nil
+}
+
+// UpdateRiskAssessmentScenario is the resolver for the updateRiskAssessmentScenario field.
+func (r *mutationResolver) UpdateRiskAssessmentScenario(ctx context.Context, input types.UpdateRiskAssessmentScenarioInput) (*types.UpdateRiskAssessmentScenarioPayload, error) {
+	if err := r.authorize(ctx, input.ID, probo.ActionRiskAssessmentScenarioUpdate); err != nil {
+		return nil, err
+	}
+	scope := coredata.NewScopeFromObjectID(input.ID)
+	scenario, err := r.riskManagement.UpdateScenario(
+		ctx,
+		scope,
+		riskmanagement.UpdateRiskAssessmentScenarioRequest{
+			ID:          input.ID,
+			Name:        input.Name,
+			Description: gqlutils.UnwrapOmittable(input.Description),
+		},
+	)
+	if err != nil {
+		if validationErrors, ok := errors.AsType[validator.ValidationErrors](err); ok {
+			return nil, gqlutils.InvalidValidationErrors(ctx, validationErrors)
+		}
+		r.logger.ErrorCtx(ctx, "cannot update risk scenario", log.Error(err))
+		return nil, gqlutils.Internal(ctx)
+	}
+	return &types.UpdateRiskAssessmentScenarioPayload{RiskAssessmentScenario: types.NewRiskAssessmentScenario(scenario)}, nil
+}
+
+// DeleteRiskAssessmentScenario is the resolver for the deleteRiskAssessmentScenario field.
+func (r *mutationResolver) DeleteRiskAssessmentScenario(ctx context.Context, input types.DeleteRiskAssessmentScenarioInput) (*types.DeleteRiskAssessmentScenarioPayload, error) {
+	if err := r.authorize(ctx, input.RiskAssessmentScenarioID, probo.ActionRiskAssessmentScenarioDelete); err != nil {
+		return nil, err
+	}
+	scope := coredata.NewScopeFromObjectID(input.RiskAssessmentScenarioID)
+	if err := r.riskManagement.DeleteScenario(ctx, scope, input.RiskAssessmentScenarioID); err != nil {
+		if errors.Is(err, coredata.ErrResourceNotFound) {
+			return nil, gqlutils.NotFound(ctx, err)
+		}
+		r.logger.ErrorCtx(ctx, "cannot delete risk scenario", log.Error(err))
+		return nil, gqlutils.Internal(ctx)
+	}
+	return &types.DeleteRiskAssessmentScenarioPayload{DeletedRiskAssessmentScenarioID: input.RiskAssessmentScenarioID}, nil
+}
+
+// LinkRiskAssessmentScenarioThreat is the resolver for the linkRiskAssessmentScenarioThreat field.
+func (r *mutationResolver) LinkRiskAssessmentScenarioThreat(ctx context.Context, input types.LinkRiskAssessmentScenarioThreatInput) (*types.LinkRiskAssessmentScenarioThreatPayload, error) {
+	if err := r.authorize(ctx, input.RiskAssessmentScenarioID, probo.ActionRiskAssessmentScenarioThreatLink); err != nil {
+		return nil, err
+	}
+	scope := coredata.NewScopeFromObjectID(input.RiskAssessmentScenarioID)
+	if err := r.riskManagement.LinkScenarioThreat(
+		ctx,
+		scope,
+		riskmanagement.LinkRiskAssessmentScenarioThreatRequest{
+			RiskAssessmentScenarioID: input.RiskAssessmentScenarioID,
+			ThreatID:                 input.ThreatID,
+		},
+	); err != nil {
+		if errors.Is(err, coredata.ErrResourceAlreadyExists) {
+			return nil, gqlutils.Conflict(ctx, err)
+		}
+		if validationErrors, ok := errors.AsType[validator.ValidationErrors](err); ok {
+			return nil, gqlutils.InvalidValidationErrors(ctx, validationErrors)
+		}
+		r.logger.ErrorCtx(ctx, "cannot link risk scenario threat", log.Error(err))
+		return nil, gqlutils.Internal(ctx)
+	}
+	scenario, err := r.riskManagement.GetScenario(ctx, scope, input.RiskAssessmentScenarioID)
+	if err != nil {
+		r.logger.ErrorCtx(ctx, "cannot load risk scenario", log.Error(err))
+		return nil, gqlutils.Internal(ctx)
+	}
+	return &types.LinkRiskAssessmentScenarioThreatPayload{RiskAssessmentScenario: types.NewRiskAssessmentScenario(scenario)}, nil
+}
+
+// UnlinkRiskAssessmentScenarioThreat is the resolver for the unlinkRiskAssessmentScenarioThreat field.
+func (r *mutationResolver) UnlinkRiskAssessmentScenarioThreat(ctx context.Context, input types.UnlinkRiskAssessmentScenarioThreatInput) (*types.UnlinkRiskAssessmentScenarioThreatPayload, error) {
+	if err := r.authorize(ctx, input.RiskAssessmentScenarioID, probo.ActionRiskAssessmentScenarioThreatUnlink); err != nil {
+		return nil, err
+	}
+	scope := coredata.NewScopeFromObjectID(input.RiskAssessmentScenarioID)
+	if err := r.riskManagement.UnlinkScenarioThreat(
+		ctx,
+		scope,
+		riskmanagement.UnlinkRiskAssessmentScenarioThreatRequest{
+			RiskAssessmentScenarioID: input.RiskAssessmentScenarioID,
+			ThreatID:                 input.ThreatID,
+		},
+	); err != nil {
+		if validationErrors, ok := errors.AsType[validator.ValidationErrors](err); ok {
+			return nil, gqlutils.InvalidValidationErrors(ctx, validationErrors)
+		}
+		r.logger.ErrorCtx(ctx, "cannot unlink risk scenario threat", log.Error(err))
+		return nil, gqlutils.Internal(ctx)
+	}
+	scenario, err := r.riskManagement.GetScenario(ctx, scope, input.RiskAssessmentScenarioID)
+	if err != nil {
+		r.logger.ErrorCtx(ctx, "cannot load risk scenario", log.Error(err))
+		return nil, gqlutils.Internal(ctx)
+	}
+	return &types.UnlinkRiskAssessmentScenarioThreatPayload{RiskAssessmentScenario: types.NewRiskAssessmentScenario(scenario)}, nil
+}
+
+// LinkRiskAssessmentScenarioRisk is the resolver for the linkRiskAssessmentScenarioRisk field.
+func (r *mutationResolver) LinkRiskAssessmentScenarioRisk(ctx context.Context, input types.LinkRiskAssessmentScenarioRiskInput) (*types.LinkRiskAssessmentScenarioRiskPayload, error) {
+	if err := r.authorize(ctx, input.RiskAssessmentScenarioID, probo.ActionRiskAssessmentScenarioRiskLink); err != nil {
+		return nil, err
+	}
+	scope := coredata.NewScopeFromObjectID(input.RiskAssessmentScenarioID)
+	if err := r.riskManagement.LinkScenarioRisk(
+		ctx,
+		scope,
+		riskmanagement.LinkRiskAssessmentScenarioRiskRequest{
+			RiskAssessmentScenarioID: input.RiskAssessmentScenarioID,
+			RiskID:                   input.RiskID,
+		},
+	); err != nil {
+		if errors.Is(err, coredata.ErrResourceAlreadyExists) {
+			return nil, gqlutils.Conflict(ctx, err)
+		}
+		if validationErrors, ok := errors.AsType[validator.ValidationErrors](err); ok {
+			return nil, gqlutils.InvalidValidationErrors(ctx, validationErrors)
+		}
+		r.logger.ErrorCtx(ctx, "cannot link risk scenario risk", log.Error(err))
+		return nil, gqlutils.Internal(ctx)
+	}
+	scenario, err := r.riskManagement.GetScenario(ctx, scope, input.RiskAssessmentScenarioID)
+	if err != nil {
+		r.logger.ErrorCtx(ctx, "cannot load risk scenario", log.Error(err))
+		return nil, gqlutils.Internal(ctx)
+	}
+	s := types.NewRiskAssessmentScenario(scenario)
+	return &types.LinkRiskAssessmentScenarioRiskPayload{
+		RiskAssessmentScenario: s,
+		RiskAssessmentScenarioEdge: &types.RiskAssessmentScenarioConnectionEdge{
+			Cursor: scenario.CursorKey(coredata.RiskAssessmentScenarioOrderFieldCreatedAt),
+			Node:   s,
+		},
+	}, nil
+}
+
+// UnlinkRiskAssessmentScenarioRisk is the resolver for the unlinkRiskAssessmentScenarioRisk field.
+func (r *mutationResolver) UnlinkRiskAssessmentScenarioRisk(ctx context.Context, input types.UnlinkRiskAssessmentScenarioRiskInput) (*types.UnlinkRiskAssessmentScenarioRiskPayload, error) {
+	if err := r.authorize(ctx, input.RiskAssessmentScenarioID, probo.ActionRiskAssessmentScenarioRiskUnlink); err != nil {
+		return nil, err
+	}
+	scope := coredata.NewScopeFromObjectID(input.RiskAssessmentScenarioID)
+	if err := r.riskManagement.UnlinkScenarioRisk(
+		ctx,
+		scope,
+		riskmanagement.UnlinkRiskAssessmentScenarioRiskRequest{
+			RiskAssessmentScenarioID: input.RiskAssessmentScenarioID,
+			RiskID:                   input.RiskID,
+		},
+	); err != nil {
+		if validationErrors, ok := errors.AsType[validator.ValidationErrors](err); ok {
+			return nil, gqlutils.InvalidValidationErrors(ctx, validationErrors)
+		}
+		r.logger.ErrorCtx(ctx, "cannot unlink risk scenario risk", log.Error(err))
+		return nil, gqlutils.Internal(ctx)
+	}
+	scenario, err := r.riskManagement.GetScenario(ctx, scope, input.RiskAssessmentScenarioID)
+	if err != nil {
+		r.logger.ErrorCtx(ctx, "cannot load risk scenario", log.Error(err))
+		return nil, gqlutils.Internal(ctx)
+	}
+	return &types.UnlinkRiskAssessmentScenarioRiskPayload{
+		RiskAssessmentScenario:          types.NewRiskAssessmentScenario(scenario),
+		DeletedRiskAssessmentScenarioID: input.RiskAssessmentScenarioID,
+	}, nil
+}
+
+// Organization is the resolver for the organization field.
+func (r *riskAssessmentResolver) Organization(ctx context.Context, obj *types.RiskAssessment) (*types.Organization, error) {
+	if err := r.authorize(ctx, obj.ID, probo.ActionOrganizationGet); err != nil {
+		return nil, err
+	}
+	loaders := dataloader.FromContext(ctx)
+	organization, err := loaders.Organization.Load(ctx, obj.Organization.ID)
+	if err != nil {
+		if errors.Is(err, coredata.ErrResourceNotFound) || errors.Is(err, dataloadgen.ErrNotFound) {
+			return nil, gqlutils.NotFound(ctx, err)
+		}
+		r.logger.ErrorCtx(ctx, "cannot get organization", log.Error(err))
+		return nil, gqlutils.Internal(ctx)
+	}
+	return types.NewOrganization(organization), nil
+}
+
+// Scopes is the resolver for the scopes field.
+func (r *riskAssessmentResolver) Scopes(ctx context.Context, obj *types.RiskAssessment, first *int, after *page.CursorKey, last *int, before *page.CursorKey, orderBy *types.RiskAssessmentScopeOrderBy) (*types.RiskAssessmentScopeConnection, error) {
+	if err := r.authorize(ctx, obj.ID, probo.ActionRiskAssessmentScopeList); err != nil {
+		return nil, err
+	}
+	scope := coredata.NewScopeFromObjectID(obj.ID)
+	pageOrderBy := page.OrderBy[coredata.RiskAssessmentScopeOrderField]{
+		Field:     coredata.RiskAssessmentScopeOrderFieldCreatedAt,
+		Direction: page.OrderDirectionDesc,
+	}
+	if orderBy != nil {
+		pageOrderBy = page.OrderBy[coredata.RiskAssessmentScopeOrderField]{Field: orderBy.Field, Direction: orderBy.Direction}
+	}
+	cursor := types.NewCursor(first, after, last, before, pageOrderBy)
+	p, err := r.riskManagement.ListScopesForRiskAssessmentID(ctx, scope, obj.ID, cursor)
+	if err != nil {
+		r.logger.ErrorCtx(ctx, "cannot list risk assessment scopes", log.Error(err))
+		return nil, gqlutils.Internal(ctx)
+	}
+	return types.NewRiskAssessmentScopeConnection(p, r, obj.ID), nil
+}
+
+// Permission is the resolver for the permission field.
+func (r *riskAssessmentResolver) Permission(ctx context.Context, obj *types.RiskAssessment, action string) (bool, error) {
+	return r.Resolver.Permission(ctx, obj, action)
+}
+
+// TotalCount is the resolver for the totalCount field.
+func (r *riskAssessmentConnectionResolver) TotalCount(ctx context.Context, obj *types.RiskAssessmentConnection) (*int, error) {
+	if err := r.authorize(ctx, obj.ParentID, probo.ActionRiskAssessmentList); err != nil {
+		return nil, err
+	}
+	scope := coredata.NewScopeFromObjectID(obj.ParentID)
+	count, err := r.riskManagement.CountForOrganizationID(ctx, scope, obj.ParentID)
+	if err != nil {
+		r.logger.ErrorCtx(ctx, "cannot count risk assessments", log.Error(err))
+		return nil, gqlutils.Internal(ctx)
+	}
+	return &count, nil
+}
+
+// TotalCount is the resolver for the totalCount field.
+func (r *riskAssessmentNodeConnectionResolver) TotalCount(ctx context.Context, obj *types.RiskAssessmentNodeConnection) (*int, error) {
+	if err := r.authorize(ctx, obj.ParentID, probo.ActionRiskAssessmentNodeList); err != nil {
+		return nil, err
+	}
+	scope := coredata.NewScopeFromObjectID(obj.ParentID)
+	count, err := r.riskManagement.CountNodesForScopeID(ctx, scope, obj.ParentID)
+	if err != nil {
+		r.logger.ErrorCtx(ctx, "cannot count risk assessment nodes", log.Error(err))
+		return nil, gqlutils.Internal(ctx)
+	}
+	return &count, nil
+}
+
+// TotalCount is the resolver for the totalCount field.
+func (r *riskAssessmentProcessConnectionResolver) TotalCount(ctx context.Context, obj *types.RiskAssessmentProcessConnection) (*int, error) {
+	if err := r.authorize(ctx, obj.ParentID, probo.ActionRiskAssessmentProcessList); err != nil {
+		return nil, err
+	}
+	scope := coredata.NewScopeFromObjectID(obj.ParentID)
+	count, err := r.riskManagement.CountProcessesForScopeID(ctx, scope, obj.ParentID)
+	if err != nil {
+		r.logger.ErrorCtx(ctx, "cannot count risk assessment processes", log.Error(err))
+		return nil, gqlutils.Internal(ctx)
+	}
+	return &count, nil
+}
+
+// Scope is the resolver for the scope field.
+func (r *riskAssessmentScenarioResolver) Scope(ctx context.Context, obj *types.RiskAssessmentScenario) (*types.RiskAssessmentScope, error) {
+	if err := r.authorize(ctx, obj.RiskAssessmentScopeID, probo.ActionRiskAssessmentScopeGet); err != nil {
+		return nil, err
+	}
+	scope := coredata.NewScopeFromObjectID(obj.RiskAssessmentScopeID)
+	raScope, err := r.riskManagement.GetScope(ctx, scope, obj.RiskAssessmentScopeID)
+	if err != nil {
+		r.logger.ErrorCtx(ctx, "cannot load risk assessment scope", log.Error(err))
+		return nil, gqlutils.Internal(ctx)
+	}
+	return types.NewRiskAssessmentScope(raScope), nil
+}
+
+// Threats is the resolver for the threats field.
+func (r *riskAssessmentScenarioResolver) Threats(ctx context.Context, obj *types.RiskAssessmentScenario, first *int, after *page.CursorKey, last *int, before *page.CursorKey, orderBy *types.RiskAssessmentThreatOrderBy) (*types.RiskAssessmentThreatConnection, error) {
+	if err := r.authorize(ctx, obj.ID, probo.ActionRiskAssessmentThreatList); err != nil {
+		return nil, err
+	}
+	scope := coredata.NewScopeFromObjectID(obj.ID)
+	pageOrderBy := page.OrderBy[coredata.RiskAssessmentThreatOrderField]{
+		Field:     coredata.RiskAssessmentThreatOrderFieldCreatedAt,
+		Direction: page.OrderDirectionDesc,
+	}
+	if orderBy != nil {
+		pageOrderBy = page.OrderBy[coredata.RiskAssessmentThreatOrderField]{Field: orderBy.Field, Direction: orderBy.Direction}
+	}
+	cursor := types.NewCursor(first, after, last, before, pageOrderBy)
+	p, err := r.riskManagement.ListThreatsForScenarioID(ctx, scope, obj.ID, cursor)
+	if err != nil {
+		r.logger.ErrorCtx(ctx, "cannot list scenario threats", log.Error(err))
+		return nil, gqlutils.Internal(ctx)
+	}
+	return types.NewRiskAssessmentThreatConnection(p, r, obj.ID), nil
+}
+
+// Risks is the resolver for the risks field.
+func (r *riskAssessmentScenarioResolver) Risks(ctx context.Context, obj *types.RiskAssessmentScenario, first *int, after *page.CursorKey, last *int, before *page.CursorKey, orderBy *types.RiskOrderBy) (*types.RiskConnection, error) {
+	if err := r.authorize(ctx, obj.ID, probo.ActionRiskList); err != nil {
+		return nil, err
+	}
+	scope := coredata.NewScopeFromObjectID(obj.ID)
+	pageOrderBy := page.OrderBy[coredata.RiskOrderField]{
+		Field:     coredata.RiskOrderFieldCreatedAt,
+		Direction: page.OrderDirectionDesc,
+	}
+	if orderBy != nil {
+		pageOrderBy = page.OrderBy[coredata.RiskOrderField]{Field: orderBy.Field, Direction: orderBy.Direction}
+	}
+	cursor := types.NewCursor(first, after, last, before, pageOrderBy)
+	p, err := r.riskManagement.ListRisksForScenarioID(ctx, scope, obj.ID, cursor)
+	if err != nil {
+		r.logger.ErrorCtx(ctx, "cannot list scenario risks", log.Error(err))
+		return nil, gqlutils.Internal(ctx)
+	}
+	return types.NewRiskConnection(p, r, obj.ID, nil), nil
+}
+
+// TotalCount is the resolver for the totalCount field.
+func (r *riskAssessmentScenarioConnectionResolver) TotalCount(ctx context.Context, obj *types.RiskAssessmentScenarioConnection) (*int, error) {
+	if err := r.authorize(ctx, obj.ParentID, probo.ActionRiskAssessmentScenarioList); err != nil {
+		return nil, err
+	}
+	scope := coredata.NewScopeFromObjectID(obj.ParentID)
+
+	switch obj.Resolver.(type) {
+	case *riskAssessmentScopeResolver:
+		count, err := r.riskManagement.CountScenariosForScopeID(ctx, scope, obj.ParentID)
+		if err != nil {
+			r.logger.ErrorCtx(ctx, "cannot count risk scenarios", log.Error(err))
+			return nil, gqlutils.Internal(ctx)
+		}
+		return &count, nil
+	case *organizationResolver:
+		count, err := r.riskManagement.CountScenariosForOrganizationID(ctx, scope, obj.ParentID)
+		if err != nil {
+			r.logger.ErrorCtx(ctx, "cannot count risk scenarios", log.Error(err))
+			return nil, gqlutils.Internal(ctx)
+		}
+		return &count, nil
+	default:
+		count, err := r.riskManagement.CountScenariosForRiskID(ctx, scope, obj.ParentID)
+		if err != nil {
+			r.logger.ErrorCtx(ctx, "cannot count risk scenarios", log.Error(err))
+			return nil, gqlutils.Internal(ctx)
+		}
+		return &count, nil
+	}
+}
+
+// Nodes is the resolver for the nodes field.
+func (r *riskAssessmentScopeResolver) Nodes(ctx context.Context, obj *types.RiskAssessmentScope, first *int, after *page.CursorKey, last *int, before *page.CursorKey, orderBy *types.RiskAssessmentNodeOrderBy) (*types.RiskAssessmentNodeConnection, error) {
+	if err := r.authorize(ctx, obj.ID, probo.ActionRiskAssessmentNodeList); err != nil {
+		return nil, err
+	}
+	scope := coredata.NewScopeFromObjectID(obj.ID)
+	pageOrderBy := page.OrderBy[coredata.RiskAssessmentNodeOrderField]{
+		Field:     coredata.RiskAssessmentNodeOrderFieldCreatedAt,
+		Direction: page.OrderDirectionDesc,
+	}
+	if orderBy != nil {
+		pageOrderBy = page.OrderBy[coredata.RiskAssessmentNodeOrderField]{Field: orderBy.Field, Direction: orderBy.Direction}
+	}
+	cursor := types.NewCursor(first, after, last, before, pageOrderBy)
+	p, err := r.riskManagement.ListNodesForScopeID(ctx, scope, obj.ID, cursor)
+	if err != nil {
+		r.logger.ErrorCtx(ctx, "cannot list risk assessment nodes", log.Error(err))
+		return nil, gqlutils.Internal(ctx)
+	}
+	return types.NewRiskAssessmentNodeConnection(p, r, obj.ID), nil
+}
+
+// Processes is the resolver for the processes field.
+func (r *riskAssessmentScopeResolver) Processes(ctx context.Context, obj *types.RiskAssessmentScope, first *int, after *page.CursorKey, last *int, before *page.CursorKey, orderBy *types.RiskAssessmentProcessOrderBy) (*types.RiskAssessmentProcessConnection, error) {
+	if err := r.authorize(ctx, obj.ID, probo.ActionRiskAssessmentProcessList); err != nil {
+		return nil, err
+	}
+	scope := coredata.NewScopeFromObjectID(obj.ID)
+	pageOrderBy := page.OrderBy[coredata.RiskAssessmentProcessOrderField]{
+		Field:     coredata.RiskAssessmentProcessOrderFieldCreatedAt,
+		Direction: page.OrderDirectionDesc,
+	}
+	if orderBy != nil {
+		pageOrderBy = page.OrderBy[coredata.RiskAssessmentProcessOrderField]{Field: orderBy.Field, Direction: orderBy.Direction}
+	}
+	cursor := types.NewCursor(first, after, last, before, pageOrderBy)
+	p, err := r.riskManagement.ListProcessesForScopeID(ctx, scope, obj.ID, cursor)
+	if err != nil {
+		r.logger.ErrorCtx(ctx, "cannot list risk assessment processes", log.Error(err))
+		return nil, gqlutils.Internal(ctx)
+	}
+	return types.NewRiskAssessmentProcessConnection(p, r, obj.ID), nil
+}
+
+// Threats is the resolver for the threats field.
+func (r *riskAssessmentScopeResolver) Threats(ctx context.Context, obj *types.RiskAssessmentScope, first *int, after *page.CursorKey, last *int, before *page.CursorKey, orderBy *types.RiskAssessmentThreatOrderBy) (*types.RiskAssessmentThreatConnection, error) {
+	if err := r.authorize(ctx, obj.ID, probo.ActionRiskAssessmentThreatList); err != nil {
+		return nil, err
+	}
+	scope := coredata.NewScopeFromObjectID(obj.ID)
+	pageOrderBy := page.OrderBy[coredata.RiskAssessmentThreatOrderField]{
+		Field:     coredata.RiskAssessmentThreatOrderFieldCreatedAt,
+		Direction: page.OrderDirectionDesc,
+	}
+	if orderBy != nil {
+		pageOrderBy = page.OrderBy[coredata.RiskAssessmentThreatOrderField]{Field: orderBy.Field, Direction: orderBy.Direction}
+	}
+	cursor := types.NewCursor(first, after, last, before, pageOrderBy)
+	p, err := r.riskManagement.ListThreatsForScopeID(ctx, scope, obj.ID, cursor)
+	if err != nil {
+		r.logger.ErrorCtx(ctx, "cannot list risk threats", log.Error(err))
+		return nil, gqlutils.Internal(ctx)
+	}
+	return types.NewRiskAssessmentThreatConnection(p, r, obj.ID), nil
+}
+
+// Scenarios is the resolver for the scenarios field.
+func (r *riskAssessmentScopeResolver) Scenarios(ctx context.Context, obj *types.RiskAssessmentScope, first *int, after *page.CursorKey, last *int, before *page.CursorKey, orderBy *types.RiskAssessmentScenarioOrderBy) (*types.RiskAssessmentScenarioConnection, error) {
+	if err := r.authorize(ctx, obj.ID, probo.ActionRiskAssessmentScenarioList); err != nil {
+		return nil, err
+	}
+	scope := coredata.NewScopeFromObjectID(obj.ID)
+	pageOrderBy := page.OrderBy[coredata.RiskAssessmentScenarioOrderField]{
+		Field:     coredata.RiskAssessmentScenarioOrderFieldCreatedAt,
+		Direction: page.OrderDirectionDesc,
+	}
+	if orderBy != nil {
+		pageOrderBy = page.OrderBy[coredata.RiskAssessmentScenarioOrderField]{Field: orderBy.Field, Direction: orderBy.Direction}
+	}
+	cursor := types.NewCursor(first, after, last, before, pageOrderBy)
+	p, err := r.riskManagement.ListScenariosForScopeID(ctx, scope, obj.ID, cursor)
+	if err != nil {
+		r.logger.ErrorCtx(ctx, "cannot list risk scenarios", log.Error(err))
+		return nil, gqlutils.Internal(ctx)
+	}
+	return types.NewRiskAssessmentScenarioConnection(p, r, obj.ID), nil
+}
+
+// TotalCount is the resolver for the totalCount field.
+func (r *riskAssessmentScopeConnectionResolver) TotalCount(ctx context.Context, obj *types.RiskAssessmentScopeConnection) (*int, error) {
+	if err := r.authorize(ctx, obj.ParentID, probo.ActionRiskAssessmentScopeList); err != nil {
+		return nil, err
+	}
+	scope := coredata.NewScopeFromObjectID(obj.ParentID)
+	count, err := r.riskManagement.CountScopesForRiskAssessmentID(ctx, scope, obj.ParentID)
+	if err != nil {
+		r.logger.ErrorCtx(ctx, "cannot count risk assessment scopes", log.Error(err))
+		return nil, gqlutils.Internal(ctx)
+	}
+	return &count, nil
+}
+
+// TotalCount is the resolver for the totalCount field.
+func (r *riskAssessmentThreatConnectionResolver) TotalCount(ctx context.Context, obj *types.RiskAssessmentThreatConnection) (*int, error) {
+	if err := r.authorize(ctx, obj.ParentID, probo.ActionRiskAssessmentThreatList); err != nil {
+		return nil, err
+	}
+	scope := coredata.NewScopeFromObjectID(obj.ParentID)
+
+	switch obj.Resolver.(type) {
+	case *riskAssessmentScenarioResolver:
+		count, err := r.riskManagement.CountThreatsForScenarioID(ctx, scope, obj.ParentID)
+		if err != nil {
+			r.logger.ErrorCtx(ctx, "cannot count scenario threats", log.Error(err))
+			return nil, gqlutils.Internal(ctx)
+		}
+		return &count, nil
+	default:
+		count, err := r.riskManagement.CountThreatsForScopeID(ctx, scope, obj.ParentID)
+		if err != nil {
+			r.logger.ErrorCtx(ctx, "cannot count risk threats", log.Error(err))
+			return nil, gqlutils.Internal(ctx)
+		}
+		return &count, nil
+	}
+}
+
+// RiskAssessment returns schema.RiskAssessmentResolver implementation.
+func (r *Resolver) RiskAssessment() schema.RiskAssessmentResolver { return &riskAssessmentResolver{r} }
+
+// RiskAssessmentConnection returns schema.RiskAssessmentConnectionResolver implementation.
+func (r *Resolver) RiskAssessmentConnection() schema.RiskAssessmentConnectionResolver {
+	return &riskAssessmentConnectionResolver{r}
+}
+
+// RiskAssessmentNodeConnection returns schema.RiskAssessmentNodeConnectionResolver implementation.
+func (r *Resolver) RiskAssessmentNodeConnection() schema.RiskAssessmentNodeConnectionResolver {
+	return &riskAssessmentNodeConnectionResolver{r}
+}
+
+// RiskAssessmentProcessConnection returns schema.RiskAssessmentProcessConnectionResolver implementation.
+func (r *Resolver) RiskAssessmentProcessConnection() schema.RiskAssessmentProcessConnectionResolver {
+	return &riskAssessmentProcessConnectionResolver{r}
+}
+
+// RiskAssessmentScenario returns schema.RiskAssessmentScenarioResolver implementation.
+func (r *Resolver) RiskAssessmentScenario() schema.RiskAssessmentScenarioResolver {
+	return &riskAssessmentScenarioResolver{r}
+}
+
+// RiskAssessmentScenarioConnection returns schema.RiskAssessmentScenarioConnectionResolver implementation.
+func (r *Resolver) RiskAssessmentScenarioConnection() schema.RiskAssessmentScenarioConnectionResolver {
+	return &riskAssessmentScenarioConnectionResolver{r}
+}
+
+// RiskAssessmentScope returns schema.RiskAssessmentScopeResolver implementation.
+func (r *Resolver) RiskAssessmentScope() schema.RiskAssessmentScopeResolver {
+	return &riskAssessmentScopeResolver{r}
+}
+
+// RiskAssessmentScopeConnection returns schema.RiskAssessmentScopeConnectionResolver implementation.
+func (r *Resolver) RiskAssessmentScopeConnection() schema.RiskAssessmentScopeConnectionResolver {
+	return &riskAssessmentScopeConnectionResolver{r}
+}
+
+// RiskAssessmentThreatConnection returns schema.RiskAssessmentThreatConnectionResolver implementation.
+func (r *Resolver) RiskAssessmentThreatConnection() schema.RiskAssessmentThreatConnectionResolver {
+	return &riskAssessmentThreatConnectionResolver{r}
+}
+
+type riskAssessmentResolver struct{ *Resolver }
+type riskAssessmentConnectionResolver struct{ *Resolver }
+type riskAssessmentNodeConnectionResolver struct{ *Resolver }
+type riskAssessmentProcessConnectionResolver struct{ *Resolver }
+type riskAssessmentScenarioResolver struct{ *Resolver }
+type riskAssessmentScenarioConnectionResolver struct{ *Resolver }
+type riskAssessmentScopeResolver struct{ *Resolver }
+type riskAssessmentScopeConnectionResolver struct{ *Resolver }
+type riskAssessmentThreatConnectionResolver struct{ *Resolver }

pkg/server/api/console/v1/risk_resolvers.go

@@ -448,6 +448,28 @@ func (r *riskResolver) Obligations(ctx context.Context, obj *types.Risk, first *
 	return types.NewObligationConnection(page, r, obj.ID), nil
 }
 
+// Scenarios is the resolver for the scenarios field.
+func (r *riskResolver) Scenarios(ctx context.Context, obj *types.Risk, first *int, after *page.CursorKey, last *int, before *page.CursorKey, orderBy *types.RiskAssessmentScenarioOrderBy) (*types.RiskAssessmentScenarioConnection, error) {
+	if err := r.authorize(ctx, obj.ID, probo.ActionRiskAssessmentScenarioList); err != nil {
+		return nil, err
+	}
+	scope := coredata.NewScopeFromObjectID(obj.ID)
+	pageOrderBy := page.OrderBy[coredata.RiskAssessmentScenarioOrderField]{
+		Field:     coredata.RiskAssessmentScenarioOrderFieldCreatedAt,
+		Direction: page.OrderDirectionDesc,
+	}
+	if orderBy != nil {
+		pageOrderBy = page.OrderBy[coredata.RiskAssessmentScenarioOrderField]{Field: orderBy.Field, Direction: orderBy.Direction}
+	}
+	cursor := types.NewCursor(first, after, last, before, pageOrderBy)
+	p, err := r.riskManagement.ListScenariosForRiskID(ctx, scope, obj.ID, cursor)
+	if err != nil {
+		r.logger.ErrorCtx(ctx, "cannot list risk scenarios", log.Error(err))
+		return nil, gqlutils.Internal(ctx)
+	}
+	return types.NewRiskAssessmentScenarioConnection(p, r, obj.ID), nil
+}
+
 // Permission is the resolver for the permission field.
 func (r *riskResolver) Permission(ctx context.Context, obj *types.Risk, action string) (bool, error) {
 	return r.Resolver.Permission(ctx, obj, action)
@@ -476,6 +498,14 @@ func (r *riskConnectionResolver) TotalCount(ctx context.Context, obj *types.Risk
 			return 0, gqlutils.Internal(ctx)
 		}
 		return count, nil
+	case *riskAssessmentScenarioResolver:
+		scope := coredata.NewScopeFromObjectID(obj.ParentID)
+		count, err := r.riskManagement.CountRisksForScenarioID(ctx, scope, obj.ParentID)
+		if err != nil {
+			r.logger.ErrorCtx(ctx, "cannot count scenario risks", log.Error(err))
+			return 0, gqlutils.Internal(ctx)
+		}
+		return count, nil
 	}
 
 	r.logger.ErrorCtx(ctx, "unsupported resolver")

pkg/server/api/console/v1/types/risk_assessment.go

@@ -0,0 +1,73 @@
+// Copyright (c) 2026 Probo Inc <hello@getprobo.com>.
+//
+// Permission to use, copy, modify, and/or distribute this software for any
+// purpose with or without fee is hereby granted, provided that the above
+// copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+// REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+// AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+// INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+// LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+// OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+package types
+
+import (
+	"go.probo.inc/probo/pkg/coredata"
+	"go.probo.inc/probo/pkg/gid"
+	"go.probo.inc/probo/pkg/page"
+)
+
+type (
+	RiskAssessmentOrderBy OrderBy[coredata.RiskAssessmentOrderField]
+
+	RiskAssessmentConnection struct {
+		TotalCount int
+		Edges      []*RiskAssessmentConnectionEdge
+		PageInfo   PageInfo
+		Resolver   any
+		ParentID   gid.GID
+	}
+)
+
+func NewRiskAssessmentConnection(
+	p *page.Page[*coredata.RiskAssessment, coredata.RiskAssessmentOrderField],
+	parentType any,
+	parentID gid.GID,
+) *RiskAssessmentConnection {
+	edges := make([]*RiskAssessmentConnectionEdge, len(p.Data))
+	for i := range edges {
+		edges[i] = &RiskAssessmentConnectionEdge{
+			Cursor: p.Data[i].CursorKey(p.Cursor.OrderBy.Field),
+			Node:   NewRiskAssessment(p.Data[i]),
+		}
+	}
+	return &RiskAssessmentConnection{
+		Edges:    edges,
+		PageInfo: *NewPageInfo(p),
+		Resolver: parentType,
+		ParentID: parentID,
+	}
+}
+
+func NewRiskAssessmentConnectionEdge(ra *coredata.RiskAssessment, orderBy coredata.RiskAssessmentOrderField) *RiskAssessmentConnectionEdge {
+	return &RiskAssessmentConnectionEdge{
+		Cursor: ra.CursorKey(orderBy),
+		Node:   NewRiskAssessment(ra),
+	}
+}
+
+func NewRiskAssessment(ra *coredata.RiskAssessment) *RiskAssessment {
+	return &RiskAssessment{
+		ID:          ra.ID,
+		Name:        ra.Name,
+		Description: ra.Description,
+		Organization: &Organization{
+			ID: ra.OrganizationID,
+		},
+		CreatedAt: ra.CreatedAt,
+		UpdatedAt: ra.UpdatedAt,
+	}
+}

pkg/server/api/console/v1/types/risk_assessment_node.go

@@ -0,0 +1,64 @@
+// Copyright (c) 2026 Probo Inc <hello@getprobo.com>.
+//
+// Permission to use, copy, modify, and/or distribute this software for any
+// purpose with or without fee is hereby granted, provided that the above
+// copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+// REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+// AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+// INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+// LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+// OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+package types
+
+import (
+	"go.probo.inc/probo/pkg/coredata"
+	"go.probo.inc/probo/pkg/gid"
+	"go.probo.inc/probo/pkg/page"
+)
+
+type (
+	RiskAssessmentNodeOrderBy OrderBy[coredata.RiskAssessmentNodeOrderField]
+
+	RiskAssessmentNodeConnection struct {
+		TotalCount int
+		Edges      []*RiskAssessmentNodeConnectionEdge
+		PageInfo   PageInfo
+		Resolver   any
+		ParentID   gid.GID
+	}
+)
+
+func NewRiskAssessmentNodeConnection(
+	p *page.Page[*coredata.RiskAssessmentNode, coredata.RiskAssessmentNodeOrderField],
+	parentType any,
+	parentID gid.GID,
+) *RiskAssessmentNodeConnection {
+	edges := make([]*RiskAssessmentNodeConnectionEdge, len(p.Data))
+	for i := range edges {
+		edges[i] = &RiskAssessmentNodeConnectionEdge{
+			Cursor: p.Data[i].CursorKey(p.Cursor.OrderBy.Field),
+			Node:   NewRiskAssessmentNode(p.Data[i]),
+		}
+	}
+	return &RiskAssessmentNodeConnection{
+		Edges:    edges,
+		PageInfo: *NewPageInfo(p),
+		Resolver: parentType,
+		ParentID: parentID,
+	}
+}
+
+func NewRiskAssessmentNode(n *coredata.RiskAssessmentNode) *RiskAssessmentNode {
+	return &RiskAssessmentNode{
+		ID:                    n.ID,
+		RiskAssessmentScopeID: n.RiskAssessmentScopeID,
+		NodeType:              n.NodeType,
+		Name:                  n.Name,
+		CreatedAt:             n.CreatedAt,
+		UpdatedAt:             n.UpdatedAt,
+	}
+}

pkg/server/api/console/v1/types/risk_assessment_process.go

@@ -0,0 +1,65 @@
+// Copyright (c) 2026 Probo Inc <hello@getprobo.com>.
+//
+// Permission to use, copy, modify, and/or distribute this software for any
+// purpose with or without fee is hereby granted, provided that the above
+// copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+// REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+// AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+// INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+// LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+// OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+package types
+
+import (
+	"go.probo.inc/probo/pkg/coredata"
+	"go.probo.inc/probo/pkg/gid"
+	"go.probo.inc/probo/pkg/page"
+)
+
+type (
+	RiskAssessmentProcessOrderBy OrderBy[coredata.RiskAssessmentProcessOrderField]
+
+	RiskAssessmentProcessConnection struct {
+		TotalCount int
+		Edges      []*RiskAssessmentProcessConnectionEdge
+		PageInfo   PageInfo
+		Resolver   any
+		ParentID   gid.GID
+	}
+)
+
+func NewRiskAssessmentProcessConnection(
+	p *page.Page[*coredata.RiskAssessmentProcess, coredata.RiskAssessmentProcessOrderField],
+	parentType any,
+	parentID gid.GID,
+) *RiskAssessmentProcessConnection {
+	edges := make([]*RiskAssessmentProcessConnectionEdge, len(p.Data))
+	for i := range edges {
+		edges[i] = &RiskAssessmentProcessConnectionEdge{
+			Cursor: p.Data[i].CursorKey(p.Cursor.OrderBy.Field),
+			Node:   NewRiskAssessmentProcess(p.Data[i]),
+		}
+	}
+	return &RiskAssessmentProcessConnection{
+		Edges:    edges,
+		PageInfo: *NewPageInfo(p),
+		Resolver: parentType,
+		ParentID: parentID,
+	}
+}
+
+func NewRiskAssessmentProcess(pr *coredata.RiskAssessmentProcess) *RiskAssessmentProcess {
+	return &RiskAssessmentProcess{
+		ID:                    pr.ID,
+		RiskAssessmentScopeID: pr.RiskAssessmentScopeID,
+		SourceNodeID:          pr.SourceNodeID,
+		TargetNodeID:          pr.TargetNodeID,
+		Name:                  pr.Name,
+		CreatedAt:             pr.CreatedAt,
+		UpdatedAt:             pr.UpdatedAt,
+	}
+}

pkg/server/api/console/v1/types/risk_assessment_scenario.go

@@ -0,0 +1,64 @@
+// Copyright (c) 2026 Probo Inc <hello@getprobo.com>.
+//
+// Permission to use, copy, modify, and/or distribute this software for any
+// purpose with or without fee is hereby granted, provided that the above
+// copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+// REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+// AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+// INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+// LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+// OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+package types
+
+import (
+	"go.probo.inc/probo/pkg/coredata"
+	"go.probo.inc/probo/pkg/gid"
+	"go.probo.inc/probo/pkg/page"
+)
+
+type (
+	RiskAssessmentScenarioOrderBy OrderBy[coredata.RiskAssessmentScenarioOrderField]
+
+	RiskAssessmentScenarioConnection struct {
+		TotalCount int
+		Edges      []*RiskAssessmentScenarioConnectionEdge
+		PageInfo   PageInfo
+		Resolver   any
+		ParentID   gid.GID
+	}
+)
+
+func NewRiskAssessmentScenarioConnection(
+	p *page.Page[*coredata.RiskAssessmentScenario, coredata.RiskAssessmentScenarioOrderField],
+	parentType any,
+	parentID gid.GID,
+) *RiskAssessmentScenarioConnection {
+	edges := make([]*RiskAssessmentScenarioConnectionEdge, len(p.Data))
+	for i := range edges {
+		edges[i] = &RiskAssessmentScenarioConnectionEdge{
+			Cursor: p.Data[i].CursorKey(p.Cursor.OrderBy.Field),
+			Node:   NewRiskAssessmentScenario(p.Data[i]),
+		}
+	}
+	return &RiskAssessmentScenarioConnection{
+		Edges:    edges,
+		PageInfo: *NewPageInfo(p),
+		Resolver: parentType,
+		ParentID: parentID,
+	}
+}
+
+func NewRiskAssessmentScenario(s *coredata.RiskAssessmentScenario) *RiskAssessmentScenario {
+	return &RiskAssessmentScenario{
+		ID:                    s.ID,
+		RiskAssessmentScopeID: s.RiskAssessmentScopeID,
+		Name:                  s.Name,
+		Description:           s.Description,
+		CreatedAt:             s.CreatedAt,
+		UpdatedAt:             s.UpdatedAt,
+	}
+}

pkg/server/api/console/v1/types/risk_assessment_scope.go

@@ -0,0 +1,70 @@
+// Copyright (c) 2026 Probo Inc <hello@getprobo.com>.
+//
+// Permission to use, copy, modify, and/or distribute this software for any
+// purpose with or without fee is hereby granted, provided that the above
+// copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+// REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+// AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+// INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+// LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+// OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+package types
+
+import (
+	"go.probo.inc/probo/pkg/coredata"
+	"go.probo.inc/probo/pkg/gid"
+	"go.probo.inc/probo/pkg/page"
+)
+
+type (
+	RiskAssessmentScopeOrderBy OrderBy[coredata.RiskAssessmentScopeOrderField]
+
+	RiskAssessmentScopeConnection struct {
+		TotalCount int
+		Edges      []*RiskAssessmentScopeConnectionEdge
+		PageInfo   PageInfo
+		Resolver   any
+		ParentID   gid.GID
+	}
+)
+
+func NewRiskAssessmentScopeConnection(
+	p *page.Page[*coredata.RiskAssessmentScope, coredata.RiskAssessmentScopeOrderField],
+	parentType any,
+	parentID gid.GID,
+) *RiskAssessmentScopeConnection {
+	edges := make([]*RiskAssessmentScopeConnectionEdge, len(p.Data))
+	for i := range edges {
+		edges[i] = &RiskAssessmentScopeConnectionEdge{
+			Cursor: p.Data[i].CursorKey(p.Cursor.OrderBy.Field),
+			Node:   NewRiskAssessmentScope(p.Data[i]),
+		}
+	}
+	return &RiskAssessmentScopeConnection{
+		Edges:    edges,
+		PageInfo: *NewPageInfo(p),
+		Resolver: parentType,
+		ParentID: parentID,
+	}
+}
+
+func NewRiskAssessmentScopeConnectionEdge(s *coredata.RiskAssessmentScope, orderBy coredata.RiskAssessmentScopeOrderField) *RiskAssessmentScopeConnectionEdge {
+	return &RiskAssessmentScopeConnectionEdge{
+		Cursor: s.CursorKey(orderBy),
+		Node:   NewRiskAssessmentScope(s),
+	}
+}
+
+func NewRiskAssessmentScope(s *coredata.RiskAssessmentScope) *RiskAssessmentScope {
+	return &RiskAssessmentScope{
+		ID:               s.ID,
+		RiskAssessmentID: s.RiskAssessmentID,
+		Name:             s.Name,
+		CreatedAt:        s.CreatedAt,
+		UpdatedAt:        s.UpdatedAt,
+	}
+}

pkg/server/api/console/v1/types/risk_assessment_threat.go

@@ -0,0 +1,65 @@
+// Copyright (c) 2026 Probo Inc <hello@getprobo.com>.
+//
+// Permission to use, copy, modify, and/or distribute this software for any
+// purpose with or without fee is hereby granted, provided that the above
+// copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+// REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+// AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+// INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+// LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+// OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+// PERFORMANCE OF THIS SOFTWARE.
+
+package types
+
+import (
+	"go.probo.inc/probo/pkg/coredata"
+	"go.probo.inc/probo/pkg/gid"
+	"go.probo.inc/probo/pkg/page"
+)
+
+type (
+	RiskAssessmentThreatOrderBy OrderBy[coredata.RiskAssessmentThreatOrderField]
+
+	RiskAssessmentThreatConnection struct {
+		TotalCount int
+		Edges      []*RiskAssessmentThreatConnectionEdge
+		PageInfo   PageInfo
+		Resolver   any
+		ParentID   gid.GID
+	}
+)
+
+func NewRiskAssessmentThreatConnection(
+	p *page.Page[*coredata.RiskAssessmentThreat, coredata.RiskAssessmentThreatOrderField],
+	parentType any,
+	parentID gid.GID,
+) *RiskAssessmentThreatConnection {
+	edges := make([]*RiskAssessmentThreatConnectionEdge, len(p.Data))
+	for i := range edges {
+		edges[i] = &RiskAssessmentThreatConnectionEdge{
+			Cursor: p.Data[i].CursorKey(p.Cursor.OrderBy.Field),
+			Node:   NewRiskAssessmentThreat(p.Data[i]),
+		}
+	}
+	return &RiskAssessmentThreatConnection{
+		Edges:    edges,
+		PageInfo: *NewPageInfo(p),
+		Resolver: parentType,
+		ParentID: parentID,
+	}
+}
+
+func NewRiskAssessmentThreat(t *coredata.RiskAssessmentThreat) *RiskAssessmentThreat {
+	return &RiskAssessmentThreat{
+		ID:                    t.ID,
+		RiskAssessmentScopeID: t.RiskAssessmentScopeID,
+		ProcessID:             t.ProcessID,
+		Name:                  t.Name,
+		Category:              t.Category,
+		CreatedAt:             t.CreatedAt,
+		UpdatedAt:             t.UpdatedAt,
+	}
+}

pkg/server/server.go

@@ -35,6 +35,7 @@ import (
 	"go.probo.inc/probo/pkg/iam/oauth2server"
 	"go.probo.inc/probo/pkg/mailman"
 	"go.probo.inc/probo/pkg/probo"
+	"go.probo.inc/probo/pkg/riskmanagement"
 	"go.probo.inc/probo/pkg/securecookie"
 	"go.probo.inc/probo/pkg/server/api"
 	"go.probo.inc/probo/pkg/server/api/compliancepage"
@@ -62,6 +63,7 @@ type Config struct {
 	CookieBanner      *cookiebanner.Service
 	Geoloc            *geoloc.Service
 	ThirdParty        *thirdparty.Service
+	RiskManagement    *riskmanagement.Service
 	Cookie            securecookie.Config
 	TokenSecret       string
 	ConnectorRegistry *connector.ConnectorRegistry
@@ -98,6 +100,7 @@ func NewServer(cfg Config) (*Server, error) {
 		CookieBanner:      cfg.CookieBanner,
 		Geoloc:            cfg.Geoloc,
 		ThirdParty:        cfg.ThirdParty,
+		RiskManagement:    cfg.RiskManagement,
 		Cookie:            cfg.Cookie,
 		TokenSecret:       cfg.TokenSecret,
 		ConnectorRegistry: cfg.ConnectorRegistry,