# 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 ```rust 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 ```rust 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 ``` rust 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 ```rust 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 ```rust Entry "propTitles" { Model: struct propTitles { anchorType: proposalTitles, anchorText: "All asserted titles" } Links: { propTitles->propTitle } } ``` ```rust Entry "propBodies" { Model: struct propBodies { anchorType: proposalBodies, anchorText: "Situational descriptions of the various assertions" } Links: { propBodies->propBody } } ``` ```rust 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 ```rust 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(()) } ) ] ``` ```rust 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(()) } ) ] ```