@anthusai/papyrus 2.0.0-next.69 → 2.0.0-next.70

package/amplify/plugins/reader-steering/function/handler.py

@@ -30,6 +30,7 @@ if _FUNCTION_DIRECTORY not in sys.path:  # a Lambda already has its code directo
     sys.path.insert(0, _FUNCTION_DIRECTORY)
 import ai_moderation  # noqa: E402
 import moderation as moderation_rules  # noqa: E402
+import proposals as proposal_rules  # noqa: E402
 
 SITE_SUBJECT = re.compile(r"ss1_[A-Za-z0-9_-]{43}")
 INTERIM_SUBJECT = re.compile(r"ssdev_[A-Za-z0-9_-]{43}")
@@ -383,7 +384,9 @@ def my_state(store: ReaderStore, profile: dict[str, Any], payload: dict[str, Any
     for stored_id, value in found.items():
         subject, dimension = wanted[stored_id]
         votes.setdefault(subject, {})[dimension] = value
-    return reply(200, {**public_profile(profile), "votes": votes})
+    # The reader's own up (1) or down (-1) vote per requested subject, by subject key (the key format of items.json).
+    subject_votes = {subject: held["up"] for subject, held in votes.items() if held.get("up") in (1, -1)}
+    return reply(200, {**public_profile(profile), "votes": votes, "subjectVotes": subject_votes})
 
 
 def set_handle(
@@ -976,6 +979,7 @@ class DynamoReaderStore:
         report_table: str = "",
         action_table: str = "",
         item_table: str = "",
+        proposal_table: str = "",
         flag_table: str = "",
     ) -> None:
         self._resource = resource
@@ -990,12 +994,45 @@ class DynamoReaderStore:
             "report": report_table,
             "action": action_table,
             "item": item_table,
+            "proposal": proposal_table,
             "flag": flag_table,
         }
 
     def _table(self, key: str) -> Any:
         return self._resource.Table(self._names[key])
 
+    def get_proposal(self, proposal_id: str) -> dict[str, Any] | None:
+        item = self._table("proposal").get_item(Key={"id": proposal_id}, ConsistentRead=True).get("Item")
+        return plain(item) if item else None
+
+    def create_proposal(self, row: dict[str, Any]) -> bool:
+        item = {**_without_none(row), "__typename": "Proposal", "updatedAt": row["createdAt"]}
+        try:
+            self._table("proposal").put_item(Item=item, ConditionExpression="attribute_not_exists(id)")
+        except Exception as error:
+            if is_conditional_failure(error):
+                return False
+            raise
+        return True
+
+    def change_proposal(self, proposal_id: str, changes: dict[str, Any], expected_state: str, now_iso: str) -> bool:
+        names = {"#st": "state", "#u": "updatedAt", **{f"#c{index}": key for index, key in enumerate(changes)}}
+        assignments = ", ".join(f"#c{index} = :c{index}" for index in range(len(changes)))
+        values = {":expected": expected_state, ":now": now_iso, **{f":c{index}": value for index, value in enumerate(changes.values())}}
+        try:
+            self._table("proposal").update_item(
+                Key={"id": proposal_id},
+                UpdateExpression=f"SET {assignments}, #u = :now",
+                ConditionExpression="#st = :expected",
+                ExpressionAttributeNames=names,
+                ExpressionAttributeValues=values,
+            )
+        except Exception as error:
+            if is_conditional_failure(error):
+                return False
+            raise
+        return True
+
     def get_profile(self, site_subject: str) -> dict[str, Any] | None:
         item = self._table("profile").get_item(Key={"id": site_subject}, ConsistentRead=True).get("Item")
         return plain(item) if item else None
@@ -1409,6 +1446,7 @@ def store_from_environment(environment: dict[str, str] | None = None) -> DynamoR
         report_table=environment.get("PAPYRUS_READER_REPORT_TABLE", ""),
         action_table=environment.get("PAPYRUS_READER_ACTION_TABLE", ""),
         item_table=environment.get("PAPYRUS_READER_ITEM_TABLE", ""),
+        proposal_table=environment.get("PAPYRUS_READER_PROPOSAL_TABLE", ""),
         flag_table=environment.get("PAPYRUS_READER_FLAG_TABLE", ""),
     )
 
@@ -1463,6 +1501,8 @@ def run_ai_worker(
 
 def handle_staff_event(event: dict[str, Any], *, store: Any, settings: ReaderSettings, now_seconds: float) -> dict[str, Any]:
     """``moderateReader`` from AppSync: an editor or admin hides, approves, promotes, bans or undoes. Answers a receipt, never an exception."""
+    if (event.get("info") or {}).get("fieldName") in proposal_rules.MUTATIONS:
+        return proposal_rules.handle_proposal_event(event, store, now_iso=iso(now_seconds))
     identity = event.get("identity") or {}
     claims = identity.get("claims") or {}
     groups = claims.get("cognito:groups") or identity.get("groups") or []

package/amplify/plugins/reader-steering/function/proposals.py

@@ -0,0 +1,255 @@
+"""The proposal record: what may be filed, which state changes are allowed, and who may make them.
+
+A proposal is a change to the map written down where readers can see it: a story draft, a new concept, a rename, a merge,
+a split, a new column or an element symbol. It is filed by AI (a reader proposer is part of the record but has no route yet)
+and steered by votes; an editor decides. Staff reach this through the ``fileProposal`` and ``transitionProposal``
+mutations (editors and admins only; the function checks the groups again). Every state change is appended to the proposal's
+``history`` in the same conditional write that changes the state, so the history and the state cannot disagree.
+
+Nothing here knows a person id. The proposer is ``"ai"`` or a reader's siteSubject, which is stored and never published; the
+actor of a change is the staff member's Cognito subject, which is stored and never published either (the public file shows
+"AI" or "Editor"). Votes are not counted here: they belong to the vote model and the snapshot joins them.
+"""
+
+from __future__ import annotations
+
+import json
+import re
+import uuid
+from dataclasses import dataclass
+from typing import Any, Protocol
+
+KINDS = ("story_draft", "new_concept", "rename", "merge", "split", "new_column", "element_symbol")
+DRAFT, IN_STEERING, EDITOR_REVIEW, APPROVED, DECLINED, OVERRIDDEN_BY_EDITOR = (
+    "draft",
+    "in_steering",
+    "editor_review",
+    "approved",
+    "declined",
+    "overridden_by_editor",
+)
+STATES = (DRAFT, IN_STEERING, EDITOR_REVIEW, APPROVED, DECLINED, OVERRIDDEN_BY_EDITOR)
+
+#: Every allowed state change. Anything not listed is refused. Approved, declined and overridden are final.
+TRANSITIONS: dict[str, tuple[str, ...]] = {
+    DRAFT: (IN_STEERING, DECLINED),
+    IN_STEERING: (EDITOR_REVIEW,),
+    EDITOR_REVIEW: (APPROVED, DECLINED, OVERRIDDEN_BY_EDITOR),
+}
+#: The changes that need a reason. Every reason is public; this one is also required, because it explains a decision against the community.
+REASON_REQUIRED = frozenset({OVERRIDDEN_BY_EDITOR})
+#: An override says what the editor decided against the community's view: approved or declined. Approve and decline are their own result.
+OVERRIDE_RESULTS = (APPROVED, DECLINED)
+
+#: How many target subjects each kind names, as (minimum, maximum), and the types a target may have.
+TARGET_COUNTS: dict[str, tuple[int, int]] = {
+    "story_draft": (0, 10),
+    "new_concept": (0, 10),
+    "rename": (1, 1),
+    "merge": (2, 10),
+    "split": (1, 1),
+    "new_column": (0, 10),
+    "element_symbol": (1, 1),
+}
+TARGET_TYPES = ("concept", "entity", "column", "story", "cluster")
+
+MUTATIONS = ("fileProposal", "transitionProposal")
+PROPOSER_AI = "ai"
+STAFF_GROUPS = frozenset({"editor", "admin"})
+PROPOSAL_ID = re.compile(r"prop-[0-9a-f]{32}")
+TARGET_ID = re.compile(r"[A-Za-z0-9][A-Za-z0-9_.:\-]{0,127}")
+MAXIMUM_TITLE = 200
+MAXIMUM_SUMMARY = 300
+MAXIMUM_BODY = 50_000
+MAXIMUM_REASON = 500
+MAXIMUM_EVIDENCE_SOURCE = 200
+MAXIMUM_EVIDENCE_SIGNALS = 1_000_000
+
+
+@dataclass
+class Outcome:
+    status: str  # "ok" or "refused"
+    id: str | None = None
+    error: str | None = None
+    message: str | None = None
+
+    def to_dict(self) -> dict[str, Any]:
+        return {"status": self.status, "id": self.id, "error": self.error, "message": self.message}
+
+
+def refused(error: str, message: str) -> Outcome:
+    return Outcome("refused", error=error, message=message)
+
+
+class ProposalStore(Protocol):
+    def get_proposal(self, proposal_id: str) -> dict[str, Any] | None: ...
+
+    def create_proposal(self, row: dict[str, Any]) -> bool: ...
+
+    def change_proposal(self, proposal_id: str, changes: dict[str, Any], expected_state: str, now_iso: str) -> bool: ...
+
+
+def staff_subject(identity: dict[str, Any]) -> str | None:
+    """The Cognito subject of an editor or admin, or ``None`` for anyone else."""
+    claims = identity.get("claims") or {}
+    groups = claims.get("cognito:groups") or identity.get("groups") or []
+    if isinstance(groups, str):
+        groups = [group.strip() for group in groups.strip("[]").replace(",", " ").split()]
+    subject = identity.get("sub")
+    if not isinstance(subject, str) or not subject or not STAFF_GROUPS.intersection(groups):
+        return None
+    return subject
+
+
+def clean_text(value: Any, limit: int) -> str | None:
+    if not isinstance(value, str):
+        return None
+    text = value.strip()
+    return text if text and len(text) <= limit else None
+
+
+def parse_json(value: Any) -> Any:
+    """AppSync delivers AWSJSON arguments as strings; the CLI and tests may pass the parsed value."""
+    if isinstance(value, str):
+        try:
+            return json.loads(value)
+        except ValueError:
+            return None
+    return value
+
+
+def clean_targets(kind: str, raw: Any) -> list[dict[str, str]] | Outcome:
+    parsed = parse_json(raw) if raw is not None else []
+    if not isinstance(parsed, list):
+        return refused("invalid_targets", "targets must be a list of {type, id}.")
+    minimum, maximum = TARGET_COUNTS[kind]
+    targets: list[dict[str, str]] = []
+    for entry in parsed:
+        if not isinstance(entry, dict) or entry.get("type") not in TARGET_TYPES or not isinstance(entry.get("id"), str) or not TARGET_ID.fullmatch(entry["id"]):
+            return refused("invalid_targets", f"Each target is {{type, id}} with a type of {', '.join(TARGET_TYPES)}.")
+        target = {"type": entry["type"], "id": entry["id"]}
+        if target in targets:
+            return refused("invalid_targets", "A target is named twice.")
+        targets.append(target)
+    if not minimum <= len(targets) <= maximum:
+        wanted = f"{minimum}" if minimum == maximum else f"{minimum} to {maximum}"
+        return refused("invalid_targets", f"A {kind} proposal names {wanted} target(s).")
+    return targets
+
+
+def clean_evidence(raw: Any) -> dict[str, Any] | None | Outcome:
+    parsed = parse_json(raw) if raw is not None else None
+    if parsed is None:
+        return None
+    if not isinstance(parsed, dict):
+        return refused("invalid_evidence", "evidence must be {signals, source}.")
+    signals, source = parsed.get("signals"), parsed.get("source")
+    if not isinstance(signals, int) or isinstance(signals, bool) or not 0 <= signals <= MAXIMUM_EVIDENCE_SIGNALS:
+        return refused("invalid_evidence", "evidence.signals must be a whole number of signals.")
+    if source is not None and clean_text(source, MAXIMUM_EVIDENCE_SOURCE) is None:
+        return refused("invalid_evidence", "evidence.source must be short text.")
+    return {"signals": signals, "source": source.strip() if isinstance(source, str) else None}
+
+
+def file_proposal(arguments: dict[str, Any], *, actor_sub: str, now_iso: str, proposal_id: str | None = None) -> tuple[dict[str, Any] | None, Outcome | None]:
+    """The new row for a proposal in ``draft``, or the refusal. The proposer is AI: reader filing has no route yet."""
+    kind = arguments.get("kind")
+    if kind not in KINDS:
+        return None, refused("invalid_kind", f"kind must be one of {', '.join(KINDS)}.")
+    title = clean_text(arguments.get("title"), MAXIMUM_TITLE)
+    if title is None:
+        return None, refused("invalid_title", f"A proposal needs a title of at most {MAXIMUM_TITLE} characters.")
+    body = arguments.get("body")  # Markus source, kept byte for byte
+    if not isinstance(body, str) or not body.strip() or len(body) > MAXIMUM_BODY:
+        return None, refused("invalid_body", "A proposal needs a body (Markus), at most 50,000 characters.")
+    summary = arguments.get("summary")
+    if summary is not None and clean_text(summary, MAXIMUM_SUMMARY) is None:
+        return None, refused("invalid_summary", f"summary is one line of at most {MAXIMUM_SUMMARY} characters.")
+    targets = clean_targets(kind, arguments.get("targets"))
+    if isinstance(targets, Outcome):
+        return None, targets
+    evidence = clean_evidence(arguments.get("evidence"))
+    if isinstance(evidence, Outcome):
+        return None, evidence
+    identifier = proposal_id or "prop-" + uuid.uuid4().hex
+    row: dict[str, Any] = {
+        "id": identifier,
+        "kind": kind,
+        "title": title,
+        "body": body,
+        "targets": json.dumps(targets),
+        "proposer": PROPOSER_AI,
+        "state": DRAFT,
+        "history": json.dumps([{"from": None, "to": DRAFT, "by": "ai", "actor": actor_sub, "reason": None, "at": now_iso}]),
+        "createdAt": now_iso,
+    }
+    if summary is not None:
+        row["summary"] = summary.strip()
+    if evidence is not None:
+        row["evidence"] = json.dumps(evidence)
+    return row, None
+
+
+def transition_plan(row: dict[str, Any], to_state: Any, reason: Any, *, actor_sub: str, now_iso: str, result: Any = None) -> dict[str, Any] | Outcome:
+    """The changes that move ``row`` to ``to_state``, or why it may not move."""
+    state = row.get("state")
+    if to_state not in STATES:
+        return refused("invalid_state", f"state must be one of {', '.join(STATES)}.")
+    if to_state not in TRANSITIONS.get(state, ()):
+        return refused("transition_not_allowed", f"A proposal in {state} cannot move to {to_state}.")
+    text = None
+    if reason is not None and str(reason).strip():
+        text = clean_text(reason, MAXIMUM_REASON)
+        if text is None:
+            return refused("invalid_reason", f"A reason is plain text of at most {MAXIMUM_REASON} characters.")
+    if to_state in REASON_REQUIRED and text is None:
+        return refused("reason_required", "Overriding the community needs a public reason.")
+    if to_state == OVERRIDDEN_BY_EDITOR:
+        if result not in OVERRIDE_RESULTS:
+            return refused("result_required", f"An override says what the editor decided: {' or '.join(OVERRIDE_RESULTS)}.")
+    elif result is not None:
+        return refused("result_not_allowed", "Only an override carries a result; approve and decline are their own.")
+    entry = {"from": state, "to": to_state, "by": "staff", "actor": actor_sub, "reason": text, "at": now_iso}
+    if result is not None:
+        entry["result"] = result
+    history = [*(parse_json(row.get("history")) or []), entry]
+    return {"state": to_state, "history": json.dumps(history)}
+
+
+def apply_transition(store: ProposalStore, *, proposal_id: Any, to_state: Any, reason: Any, actor_sub: str, now_iso: str, result: Any = None) -> Outcome:
+    if not isinstance(proposal_id, str) or not PROPOSAL_ID.fullmatch(proposal_id):
+        return refused("invalid_proposal", "That is not a proposal id.")
+    row = store.get_proposal(proposal_id)
+    if row is None:
+        return refused("not_found", "There is no such proposal.")
+    plan = transition_plan(row, to_state, reason, actor_sub=actor_sub, now_iso=now_iso, result=result)
+    if isinstance(plan, Outcome):
+        return plan
+    if not store.change_proposal(proposal_id, plan, row["state"], now_iso):
+        return refused("target_changed", "Someone else changed that proposal first.")
+    return Outcome("ok", id=proposal_id)
+
+
+def handle_proposal_event(event: dict[str, Any], store: ProposalStore, *, now_iso: str) -> dict[str, Any]:
+    """``fileProposal`` or ``transitionProposal`` from AppSync. Answers a receipt, never an exception."""
+    actor = staff_subject(event.get("identity") or {})
+    if actor is None:
+        return refused("not_staff", "Only editors and admins can file or decide proposals.").to_dict()
+    arguments = event.get("arguments") or {}
+    field = (event.get("info") or {}).get("fieldName")
+    if field == "fileProposal":
+        row, problem = file_proposal(arguments, actor_sub=actor, now_iso=now_iso)
+        if problem is not None:
+            return problem.to_dict()
+        if not store.create_proposal(row):
+            return refused("exists", "That proposal already exists.").to_dict()
+        return Outcome("ok", id=row["id"]).to_dict()
+    return apply_transition(
+        store,
+        proposal_id=arguments.get("proposalId"),
+        to_state=arguments.get("state"),
+        reason=arguments.get("reason"),
+        result=arguments.get("result"),
+        actor_sub=actor,
+        now_iso=now_iso,
+    ).to_dict()

package/amplify/plugins/reader-steering/papyrus.plugin.js

@@ -14,8 +14,8 @@ export const READER_POLL_SECRET_PARAMETER_ENV = "PAPYRUS_READER_POLL_SECRET_PARA
 export const readerSteeringManifest = {
     name: "reader-steering",
     contract: 1,
-    models: ["ReaderProfile", "ReaderHandle", "ReaderVote", "ReaderFlag", "ReaderSubmission", "ReaderComment", "ReaderReport", "ModerationAction"],
-    mutations: ["moderateReader"],
+    models: ["ReaderProfile", "ReaderHandle", "ReaderVote", "ReaderFlag", "ReaderSubmission", "ReaderComment", "ReaderReport", "ModerationAction", "Proposal"],
+    mutations: ["moderateReader", "fileProposal", "transitionProposal"],
     guest: { mutations: [] },
     newsroomPanels: [{ id: "moderation", label: "Moderation" }],
     staticAssets: ["_plugins/papyrus-reader@1.js", "_plugins/papyrus-reader@1.css"],
@@ -102,6 +102,7 @@ export const readerSteeringPlugin = {
     publicSettings: (config) => ({
         contract: readerSteeringManifest.contract,
         dimensions: config.dimensions,
+        subjects: { types: config.subjects.types },
         moderation: { mode: config.moderation.mode },
     }),
     wire(backend, config, context) {
@@ -117,6 +118,7 @@ export const readerSteeringPlugin = {
             ["PAPYRUS_READER_COMMENT_TABLE", "ReaderComment"],
             ["PAPYRUS_READER_REPORT_TABLE", "ReaderReport"],
             ["PAPYRUS_READER_ACTION_TABLE", "ModerationAction"],
+            ["PAPYRUS_READER_PROPOSAL_TABLE", "Proposal"],
         ]) {
             tables[model].grantReadWriteData(lambda);
             lambda.addEnvironment(variable, tables[model].tableName);
@@ -133,6 +135,8 @@ export const readerSteeringPlugin = {
         // The snapshot reads submissions, and the review step writes their signals and moderation state.
         tables.ReaderSubmission.grantReadWriteData(contentActions);
         tables.ReaderComment.grantReadWriteData(contentActions);
+        // The snapshot reads proposals and freezes the community result of one that reaches editor review.
+        tables.Proposal.grantReadWriteData(contentActions);
         lambda.addEnvironment("PAPYRUS_READER_SETTINGS", JSON.stringify(readerActionsSettings(config, interimSubjectsAllowedAtSynth())));
         if (config.reservedConcurrency !== undefined) {
             lambda.node.defaultChild.addPropertyOverride("ReservedConcurrentExecutions", config.reservedConcurrency);

package/amplify/plugins/reader-steering/papyrus.plugin.ts

@@ -21,8 +21,8 @@ export const READER_POLL_SECRET_PARAMETER_ENV = "PAPYRUS_READER_POLL_SECRET_PARA
 export const readerSteeringManifest: PluginManifest = {
   name: "reader-steering",
   contract: 1,
-  models: ["ReaderProfile", "ReaderHandle", "ReaderVote", "ReaderFlag", "ReaderSubmission", "ReaderComment", "ReaderReport", "ModerationAction"],
-  mutations: ["moderateReader"],
+  models: ["ReaderProfile", "ReaderHandle", "ReaderVote", "ReaderFlag", "ReaderSubmission", "ReaderComment", "ReaderReport", "ModerationAction", "Proposal"],
+  mutations: ["moderateReader", "fileProposal", "transitionProposal"],
   guest: { mutations: [] },
   newsroomPanels: [{ id: "moderation", label: "Moderation" }],
   staticAssets: ["_plugins/papyrus-reader@1.js", "_plugins/papyrus-reader@1.css"],
@@ -120,6 +120,7 @@ export const readerSteeringPlugin: PapyrusPlugin<ReaderSteeringConfig, { readerA
   publicSettings: (config) => ({
     contract: readerSteeringManifest.contract,
     dimensions: config.dimensions,
+    subjects: { types: config.subjects.types },
     moderation: { mode: config.moderation.mode },
   }),
   wire(backend, config, context: PluginWiringContext) {
@@ -136,6 +137,7 @@ export const readerSteeringPlugin: PapyrusPlugin<ReaderSteeringConfig, { readerA
       ["PAPYRUS_READER_COMMENT_TABLE", "ReaderComment"],
       ["PAPYRUS_READER_REPORT_TABLE", "ReaderReport"],
       ["PAPYRUS_READER_ACTION_TABLE", "ModerationAction"],
+      ["PAPYRUS_READER_PROPOSAL_TABLE", "Proposal"],
     ] as const) {
       tables[model].grantReadWriteData(lambda);
       lambda.addEnvironment(variable, tables[model].tableName);
@@ -152,6 +154,8 @@ export const readerSteeringPlugin: PapyrusPlugin<ReaderSteeringConfig, { readerA
     // The snapshot reads submissions, and the review step writes their signals and moderation state.
     tables.ReaderSubmission.grantReadWriteData(contentActions);
     tables.ReaderComment.grantReadWriteData(contentActions);
+    // The snapshot reads proposals and freezes the community result of one that reaches editor review.
+    tables.Proposal.grantReadWriteData(contentActions);
 
     lambda.addEnvironment("PAPYRUS_READER_SETTINGS", JSON.stringify(readerActionsSettings(config, interimSubjectsAllowedAtSynth())));
     if (config.reservedConcurrency !== undefined) {

package/amplify/plugins/reader-steering/schema.js

@@ -134,6 +134,54 @@ export function readerSteeringSchemaDefinitions() {
             .disableOperations(["subscriptions"])
             .secondaryIndexes((index) => [index("target").sortKeys(["at"]).name("actionsByTarget").queryField("listModerationActionsByTargetAndAt")])
             .authorization(staffOnly),
+        Proposal: a
+            .model({
+            id: a.id().required(),
+            kind: a.string().required(),
+            title: a.string().required(),
+            summary: a.string(),
+            body: a.string().required(),
+            targets: a.json().required(),
+            evidence: a.json(),
+            proposer: a.string().required(),
+            state: a.string().required(),
+            history: a.json().required(),
+            communityResult: a.json(),
+            createdAt: a.datetime().required(),
+        })
+            .disableOperations(["subscriptions"])
+            .secondaryIndexes((index) => [index("state").sortKeys(["createdAt"]).name("proposalsByState").queryField("listProposalsByStateAndCreatedAt")])
+            .authorization(staffOnly),
+        ProposalReceipt: a.customType({
+            status: a.string().required(),
+            id: a.string(),
+            error: a.string(),
+            message: a.string(),
+        }),
+        fileProposal: a
+            .mutation()
+            .arguments({
+            kind: a.string().required(),
+            title: a.string().required(),
+            body: a.string().required(),
+            summary: a.string(),
+            targets: a.json(),
+            evidence: a.json(),
+        })
+            .returns(a.ref("ProposalReceipt"))
+            .authorization((allow) => [allow.group("editor"), allow.group("admin")])
+            .handler(a.handler.function(readerActions)),
+        transitionProposal: a
+            .mutation()
+            .arguments({
+            proposalId: a.string().required(),
+            state: a.string().required(),
+            reason: a.string(),
+            result: a.string(),
+        })
+            .returns(a.ref("ProposalReceipt"))
+            .authorization((allow) => [allow.group("editor"), allow.group("admin")])
+            .handler(a.handler.function(readerActions)),
         ModerationReceipt: a.customType({
             status: a.string().required(),
             id: a.string(),

package/amplify/plugins/reader-steering/schema.ts

@@ -136,6 +136,54 @@ export function readerSteeringSchemaDefinitions() {
       .disableOperations(["subscriptions"])
       .secondaryIndexes((index) => [index("target").sortKeys(["at"]).name("actionsByTarget").queryField("listModerationActionsByTargetAndAt")])
       .authorization(staffOnly),
+    Proposal: a
+      .model({
+        id: a.id().required(),
+        kind: a.string().required(),
+        title: a.string().required(),
+        summary: a.string(),
+        body: a.string().required(),
+        targets: a.json().required(),
+        evidence: a.json(),
+        proposer: a.string().required(),
+        state: a.string().required(),
+        history: a.json().required(),
+        communityResult: a.json(),
+        createdAt: a.datetime().required(),
+      })
+      .disableOperations(["subscriptions"])
+      .secondaryIndexes((index) => [index("state").sortKeys(["createdAt"]).name("proposalsByState").queryField("listProposalsByStateAndCreatedAt")])
+      .authorization(staffOnly),
+    ProposalReceipt: a.customType({
+      status: a.string().required(),
+      id: a.string(),
+      error: a.string(),
+      message: a.string(),
+    }),
+    fileProposal: a
+      .mutation()
+      .arguments({
+        kind: a.string().required(),
+        title: a.string().required(),
+        body: a.string().required(),
+        summary: a.string(),
+        targets: a.json(),
+        evidence: a.json(),
+      })
+      .returns(a.ref("ProposalReceipt"))
+      .authorization((allow) => [allow.group("editor"), allow.group("admin")])
+      .handler(a.handler.function(readerActions)),
+    transitionProposal: a
+      .mutation()
+      .arguments({
+        proposalId: a.string().required(),
+        state: a.string().required(),
+        reason: a.string(),
+        result: a.string(),
+      })
+      .returns(a.ref("ProposalReceipt"))
+      .authorization((allow) => [allow.group("editor"), allow.group("admin")])
+      .handler(a.handler.function(readerActions)),
     ModerationReceipt: a.customType({
       status: a.string().required(),
       id: a.string(),

package/package.json

@@ -434,7 +434,7 @@
       "optional": true
     }
   },
-  "version": "2.0.0-next.69",
+  "version": "2.0.0-next.70",
   "dependencies": {
     "@aws-amplify/adapter-nextjs": "^1.7.3",
     "@aws-crypto/sha256-js": "5.2.0",

package/routes.manifest.json

@@ -1,5 +1,5 @@
 {
-  "version": "2.0.0-next.69",
+  "version": "2.0.0-next.70",
   "routes": [
     {
       "file": "app/%5F_preview/[[...path]]/route.ts",