# Proposals/Agreements

## System Requirements/Expected Behaviour
**Initialisation** (structure)
- Answer - Proposal title (assertion)
- Situation - Proposal body (context)
- Question - Title reframe (driver)

**Deliberation options** (feeback)
- Add alternative proposal and link to question
- Add alternative question and link to assertion
- Add alternative question and branch
--------

## Proposals flow: (objects)
#### Declaritive narrative: general user
- As a: participant
- I want: to voice my opinions
- So that: my perspective informs any action taken on my behalf

---------
#### Declaritive scenario: proposal contemplation
- Given: we are generally impulsive
- When: making assertions/proposals/decisions
- Then: we should provide *dialectical structures*: tools relating to the logical discussion of ideas and opinions, for deliberation.

-------
#### Declaritive scenario: deliberation
- Given: we should provide dialectical structures
- When: aggregating discourse
- Then: we should link the structures of assertions, context and drivers (aka situations, answers and questions)

-----------
#### Declaritive scenario: auto-reduction
- Given: lots of proposals which vary in quality
- When: we want to filter for relevance
- Then: recommendations should be based on a matrix of aggrigated pairwise votes

### Profile

Entry "profile" {
    Model: struct profile {
        agentAddress: 'address',
        firstName: 'string',
        lastName: 'base64',
        email: 'string',
        country: 'string',
        last_header_address: Option<Address>,
    }
    Links: {
        profile->profiles
        profile->propTitle
        profile->propBody
        profile->propDriver
    }
}

### Answer - Proposal Title

Entry "propTitle" {
    Model: struct propTitle {
        author: 'agentAddress'
        propTitle: 'string
        last_header_address: Option<Address>
    }
    Links: {
        propTitle->propTitles
        propTitle->propBody
        propTitle->propDriver
        propTitle->profile
    }
}

### Situation - Proposal Body

Entry "propBody" {
    Model: struct propBody {
        author: 'string'
        propBody: 'string'
        photo: 'base64'
        last_header_address: Option<Address>
    }
    Links: {
        propBody->propBodies
        propBody->propDriver
        propBody->profile
        propBody->propTitle
    }
}

### Question - Proposal Driver

Entry "propDriver" {
    Model: struct question {
        entryName:'Proposal Driver'
        author: 'string'
        question: 'string'
        last_header_address: Option<Address>
 Links: {
        propDriver->propDrivers
        propDriver->profile
        propDriver->propTitle
        propDriver->propBody
    }
}

### Anchors

Entry "propTitles" {
    Model: struct propTitles {
        anchorType: proposalTitles,
        anchorText: "All asserted titles"
    }
    Links: {
        propTitles->propTitle
    }
}

Entry "propBodies" {
    Model: struct propBodies {
        anchorType: proposalBodies,
        anchorText: "Situational descriptions of the various assertions"
    }
    Links: {
        propBodies->propBody
    }
}

Entry "propDrivers" {
    Model: struct propDrivers {
        anchorType: proposalDrivers,
        anchorText: "Questions driving the dileberation" 
    }
    Links: {
        propTitles->propTitle
    }
}

----------
Bullshit/draft work from here --->

----------

## Agreements flow: (functions)
#### Types

**Thoughts**
Proposals surface via pairwise preferences according to agents ontologies. This only sorts an agents preference. When we get to the crowd level then we need to weigh all preferences of individuals against eachother to sort on the global level. When we get to a sufficient level to take action then we need to sign off. At this point we might consider a "safe to take action?" prompt of some sort that suggests that as votes have self-selected up to a certain level, we need a way for people to object to bad consensus. (i.e. object to the best of a bad lot)

- Amplify/Attenuate
- Threshold

--------
- Given: a proposal
- When: I want to signal my opinion
- Then: I should be able to amplify, attenuate or abstain from it

-------
- Given: I want to amplify a proposal
- When: I find one I like
- Then: I should be

-------
### Links

links: [
            from!(
                propTitle",
                link_type: "propTitle->propTitles",
                validation_package: || {
                    hdk::ValidationPackageDefinition::Entry
                },
                validation: | _validation_data: hdk::LinkValidationData| {
                    Ok(())
                }
            ),
            to!(
                "propTitles",
                link_type: "propTitles->propTitle",
                validation_package: || {
                    hdk::ValidationPackageDefinition::Entry
                },
                validation: | _validation_data: hdk::LinkValidationData| {
                    Ok(())
                }
            )
        ]

links: [
            from!(
                "propBody",
                link_type: "propBody->propBodies",
                validation_package: || {
                    hdk::ValidationPackageDefinition::Entry
                },
                validation: | _validation_data: hdk::LinkValidationData| {
                    Ok(())
                }
            ),
            to!(
                "propBodies",
                link_type: "propBodies->propBody",
                validation_package: || {
                    hdk::ValidationPackageDefinition::Entry
                },
                validation: | _validation_data: hdk::LinkValidationData| {
                    Ok(())
                }
            )
        ]