The patch is now merged and closed :).

```

╭───────────────────────────────────────────────────────────────────────────────────────────────╮

│ Define power requirements a07ef77 R2 f6484e0 (flux-capacitor-power, master) ahead 3, behind 0 │

├───────────────────────────────────────────────────────────────────────────────────────────────┤

use anyhow::anyhow;

use radicle::cob::patch::PatchId;

use radicle::{prelude::*, Node};

Usage

    rad patch

    rad patch show <id>

    rad patch open [<option>...]

    rad patch update <id> [<option>...]

    -m, --message [<string>]   Provide a comment message to the patch or revision (default: prompt)

        --no-message           Leave the patch or revision comment message blank

        --help                 Print help

"#,

    Checkout {

        patch_id: Rev,

    },

}

#[derive(Debug)]

        let mut patch_id = None;

        let mut message = Message::default();

        let mut push = true;

        while let Some(arg) = parser.next()? {

            match arg {

                    push = false;

                }

                // Common.

                Long("verbose") | Short('v') => {

                    verbose = true;

        let op = match op.unwrap_or_default() {

            OperationName::Open => Operation::Open { message },

            OperationName::Show => Operation::Show {

                patch_id: patch_id.ok_or_else(|| anyhow!("a patch id must be provided"))?,

            },

        Operation::Open { ref message } => {

            create::run(&repository, &profile, &workdir, message.clone(), options)?;

        }

        }

        Operation::Show { patch_id } => {

            let patch_id = patch_id.resolve(&repository.backend)?;

use anyhow::anyhow;

use radicle::cob::patch::{Patch, PatchId, Patches, Revision, Verdict};

use radicle::git;

use radicle::prelude::*;

    repository: &Repository,

    profile: &Profile,

    workdir: Option<git::raw::Repository>,

) -> anyhow::Result<()> {

    let me = *profile.id();

    let patches = Patches::open(repository)?;

    // Patches the user authored.

    let mut own = Vec::new();

    // Patches other users authored.

    let mut other = Vec::new();

        if patch.author().id().as_key() == &me {

            own.push((id, patch));

        } else {

                  "open": 1,

                  "draft": 0,

                  "archived": 0,

                },

                "issues": {

                  "open": 1,

                  "open": 1,

                  "draft": 0,

                  "archived": 0,

                },

                "issues": {

                  "open": 1,

                 "open": 1,

                 "draft": 0,

                 "archived": 0,

               },

               "issues": {

                 "open": 1,

              },

              "title": "A new `hello world`",

              "description": "change `hello world` in README to something else",

              "target": "delegates",

              "tags": [],

              "revisions": [

        store::{self, FromHistory as _, Transaction},

    },

    identity::{doc::DocError, Did, Identity, IdentityError},

    storage::{git as storage, RemoteId, WriteRepository},

};

        &*TYPENAME

    }

        for op in ops {

            let id = op.id;

            let author = Author::new(op.author);

                }

                Action::Thread { revision, action } => match self.revisions.get_mut(&revision) {

                            op.id,

                            action,

                            op.author,

                            op.timestamp,

                            op.clock,

                    Some(Redactable::Redacted) => return Err(ApplyError::Redacted(revision)),

                    None => return Err(ApplyError::Missing(revision)),

                },

        operations(&mut tx)?;

        let (ops, clock, commit) = tx.commit(message, self.id, &mut self.store.raw, signer)?;

        self.clock = clock;

        Ok(commit)

use crate::cob::thread::{CommentId, Thread};

use crate::cob::{store, ActorId, EntryId, ObjectId, TypeName};

use crate::crypto::Signer;

use crate::storage::git as storage;

/// Issue operation.

        &*TYPENAME

    }

        for op in ops {

            match op.action {

                Action::Assign { add, remove } => {

                    }

                }

                Action::Thread { action } => {

                }

            }

        }

        operations(&mut tx)?;

        let (ops, clock, commit) = tx.commit(message, self.id, &mut self.store.raw, signer)?;

        self.clock = clock;

        Ok(commit)

use radicle_crdt::clock::Lamport;

use radicle_crypto::PublicKey;

/// The author of an [`Op`].

pub type ActorId = PublicKey;

    pub clock: Lamport,

    /// Timestamp of this operation.

    pub timestamp: clock::Physical,

}

impl<A: Eq> PartialOrd for Op<A> {

        author: ActorId,

        timestamp: impl Into<clock::Physical>,

        clock: Lamport,

    ) -> Self {

        Self {

            id,

            author,

            clock,

            timestamp: timestamp.into(),

        }

    }

    fn try_from(entry: &'a EntryWithClock) -> Result<Self, Self::Error> {

        let id = *entry.id();

        let ops = entry

            .changes()

            .map(|blob| {

                    author: *entry.actor(),

                    clock: entry.clock().into(),

                    timestamp: entry.timestamp().into(),

                };

                Ok::<_, Self::Error>(op)

            })

use crate::cob::{store, ActorId, EntryId, ObjectId, TypeName};

use crate::crypto::{PublicKey, Signer};

use crate::git;

use crate::prelude::*;

use crate::storage::git as storage;

    /// Error applying an op to the patch thread.

    #[error("thread apply failed: {0}")]

    Thread(#[from] thread::OpError),

}

/// Error updating or creating patches.

        &*TYPENAME

    }

        for op in ops {

            let id = op.id;

            let author = Author::new(op.author);

                            .into(),

                            op.clock,

                        );

                    } else {

                        return Err(ApplyError::Missing(revision));

                    }

                    // TODO(cloudhead): Make sure we can deal with redacted revisions which are added

                    // to out of order, like in the `Merge` case.

                    if let Some(Redactable::Present(revision)) = self.revisions.get_mut(&revision) {

                    } else {

                        return Err(ApplyError::Missing(revision));

                    }

    Open,

    Draft,

    Archived,

}

impl fmt::Display for State {

            Self::Archived => write!(f, "archived"),

            Self::Draft => write!(f, "draft"),

            Self::Open => write!(f, "open"),

        }

    }

}

        operations(&mut tx)?;

        let (ops, clock, commit) = tx.commit(message, self.id, &mut self.store.raw, signer)?;

        self.clock = clock;

        Ok(commit)

    pub open: usize,

    pub draft: usize,

    pub archived: usize,

}

pub struct Patches<'a> {

                        State::Draft => state.draft += 1,

                        State::Open => state.open += 1,

                        State::Archived => state.archived += 1,

                    }

                    state

                });

    /// Get proposed patches.

    pub fn proposed(

        &self,

        let all = self.all()?;

        Ok(all

    use crate::cob::test::Actor;

    use crate::crypto::test::signer::MockSigner;

    use crate::test;

    #[derive(Clone)]

    struct Changes<const N: usize> {

    #[test]

    fn prop_invariants() {

            let t = Patch::default();

            let [p1, p2, p3] = log.permutations;

            let mut t1 = t.clone();

                return TestResult::discard();

            }

            let mut t2 = t.clone();

                return TestResult::discard();

            }

            let mut t3 = t;

                return TestResult::discard();

            }

        qcheck::QuickCheck::new()

            .min_tests_passed(100)

            .gen(qcheck::Gen::new(7))

    }

    #[test]

        let oid = git::Oid::from_str("518d5069f94c03427f694bb494ac1cd7d1339380").unwrap();

        let mut alice = Actor::<_, Action>::new(MockSigner::default());

        let mut patch = Patch::default();

        let a1 = alice.op(Action::Revision {

            description: String::new(),

            commit: oid,

        });

        assert!(patch.revisions().next().is_some());

        assert!(patch.revisions().next().is_none());

    }

    #[test]

    fn test_revision_redact_reinsert() {

        let base = git::Oid::from_str("cb18e95ada2bb38aadd8e6cef0963ce37a87add3").unwrap();

        let oid = git::Oid::from_str("518d5069f94c03427f694bb494ac1cd7d1339380").unwrap();

        let mut alice = Actor::<_, Action>::new(MockSigner::default());

        let mut p1 = Patch::default();

        let mut p2 = Patch::default();

        });

        let a2 = alice.op(Action::Redact { revision: a1.id() });

        assert_eq!(p1, p2);

    }

    fn test_revision_merge_reinsert() {

        let base = git::Oid::from_str("cb18e95ada2bb38aadd8e6cef0963ce37a87add3").unwrap();

        let oid = git::Oid::from_str("518d5069f94c03427f694bb494ac1cd7d1339380").unwrap();

        let mut alice = Actor::<_, Action>::new(MockSigner::default());

        let mut p1 = Patch::default();

        let mut p2 = Patch::default();

            commit: oid,

        });

        assert_eq!(p1, p2);

    }

    fn type_name() -> &'static TypeName;

    /// Apply a list of operations to the state.

    /// Create an object from a history.

        let obj = history.traverse(Self::default(), |mut acc, entry| {

            match Ops::try_from(entry) {

                Ok(Ops(ops)) => {

                        log::warn!("Error applying op to `{}` state: {err}", Self::type_name());

                        return ControlFlow::Break(acc);

                    }

    /// Create an object from individual operations.

    /// Returns an error if any of the operations fails to apply.

        let mut state = Self::default();

        Ok(state)

    }

                contents,

            },

        )?;

        self.repo.sign_refs(signer).map_err(Error::SignRefs)?;

            if cob.manifest().history_type != HISTORY_TYPE {

                return Err(Error::HistoryType(cob.manifest().history_type.clone()));

            }

            Ok(Some((obj, clock)))

        } else {

    /// Return all objects.

    pub fn all(

        &self,

        let raw = cob::list(self.repo, T::type_name())?;

        Ok(raw.into_iter().map(|o| {

            Ok((*o.id(), obj, clock))

        }))

    }

        let author = self.actor;

        let timestamp = object.history().timestamp().into();

        let clock = self.clock.tick();

        // The history clock should be in sync with the tx clock.

        assert_eq!(object.history().clock(), self.clock.get());

                author,

                clock,

                timestamp,

            })

            .collect();

        let author = *self.signer.public_key();

        let clock = self.clock.tick();

        let timestamp = clock::Physical::now();

        let op = Op {

            id,

            action,

            author,

            clock,

            timestamp,

        };

        self.ops.insert((self.clock, author), op.clone());

use crate::cob;

use crate::cob::common::{Reaction, Timestamp};

use crate::cob::{ActorId, EntryId, Op};

use crdt::clock::Lamport;

use crdt::{GMap, GSet, LWWSet, Max, Redactable, Semilattice};

        &*TYPENAME

    }

        for op in ops.into_iter() {

            let id = op.id;

            let author = op.author;

    use crate::cob::test;

    use crate::crypto::test::signer::MockSigner;

    use crate::crypto::Signer;

    /// An object that can be used to create and sign changes.

    pub struct Actor<G> {

    fn test_redact_comment() {

        let tmp = tempfile::tempdir().unwrap();

        let (_, signer, _) = radicle::test::setup::context(&tmp);

        let mut alice = Actor::new(signer);

        let mut thread = Thread::default();

        let a1 = alice.comment("Second comment", Some(a0.id()));

        let a2 = alice.comment("Third comment", Some(a0.id()));

        assert_eq!(thread.comments().count(), 3);

        // Redact the second comment.

        let a3 = alice.redact(a1.id());

        let (_, comment0) = thread.comments().nth(0).unwrap();

        let (_, comment1) = thread.comments().nth(1).unwrap();

    #[test]

    fn test_edit_comment() {

        let mut alice = Actor::<MockSigner>::default();

        let c0 = alice.comment("Hello world!", None);

        let c1 = alice.edit(c0.id(), "Goodbye world.");

        let c2 = alice.edit(c0.id(), "Goodbye world!");

        let mut t1 = Thread::default();

        let comment = t1.comment(&c0.id());

        let edits = comment.unwrap().edits().collect::<Vec<_>>();

        assert_eq!(t1.comment(&c0.id()).unwrap().body(), "Goodbye world!");

        let mut t2 = Thread::default();

        assert_eq!(t1, t2);

    }

    #[test]

    fn test_histories() {

        let mut alice = Actor::<MockSigner>::default();

        let mut bob = Actor::<MockSigner>::default();

        let mut eve = Actor::<MockSigner>::default();

        a.merge(b);

        a.merge(e);

        for permutation in a.permutations(2) {

            assert_eq!(actual, expected);

        }

    }

    #[test]

    fn test_duplicate_comments() {

        let mut alice = Actor::<MockSigner>::default();

        let mut bob = Actor::<MockSigner>::default();

        b.append(&b0);

        a.merge(b);

        assert_eq!(thread.comments().count(), 2);

    #[test]

    fn test_duplicate_comments_same_author() {

        let mut alice = Actor::<MockSigner>::default();

        let a0 = alice.comment("Hello World!", None);

        h3.merge(h1);

        h3.merge(h2);

        // The three comments, distinct yet identical in terms of content, are preserved.

        assert_eq!(thread.comments().count(), 3);

    #[test]

    fn test_comment_edit_reinsert() {

        let mut alice = Actor::<MockSigner>::default();

        let mut t1 = Thread::default();

        let mut t2 = Thread::default();

        let a1 = alice.comment("Hello.", None);

        let a2 = alice.edit(a1.id(), "Hello World.");

        assert_eq!(t1, t2);

    }

    #[test]

    fn prop_invariants() {

            let t = Thread::default();

            let [p1, p2, p3] = log.permutations;

            let mut t1 = t.clone();

                return TestResult::discard();

            }

            let mut t2 = t.clone();

                return TestResult::discard();

            }

            let mut t3 = t;

                return TestResult::discard();

            }

            .min_tests_passed(100)

            .max_tests(10000)

            .gen(qcheck::Gen::new(7))

    }

}

    pub sigs: HashMap<PublicKey, Signature>,

}

/// An identity document.

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]

#[serde(rename_all = "camelCase")]

    }

    /// Get the repository's identity document.

}

/// Allows read-write access to a repository.

use crate::git;

use crate::identity;

use crate::identity::{Doc, Id};

use crate::identity::{Identity, IdentityError, Project};

use crate::storage::refs;

        Ok(Remotes::from_iter(remotes))

    }

    }

    fn head(&self) -> Result<(Qualified, Oid), IdentityError> {

use crate::node::Address;

use crate::storage;

use crate::storage::refs::{Refs, SignedRefs};

pub fn oid() -> storage::Oid {

    let oid_bytes: [u8; 20] = gen(1);

    }

}

impl Arbitrary for storage::Remote<crypto::Verified> {

    fn arbitrary(g: &mut qcheck::Gen) -> Self {

        let refs = Refs::arbitrary(g);

use radicle_git_ext as git_ext;

use crate::crypto::{Signer, Verified};

use crate::identity::IdentityError;

use crate::node::NodeId;

    remotes: HashMap<NodeId, refs::SignedRefs<Verified>>,

}

impl ReadRepository for MockRepository {

    fn id(&self) -> Id {

        self.id

        Ok((git2::Oid::zero().into(), self.doc.clone().unverified()))

    }

    fn identity_head(&self) -> Result<Oid, IdentityError> {

        todo!()

    }