✓ Target met: 1 seed(s)

🌱 Fetched from z6Mkt67GdsW7715MEfRuP4pSZxJRJh6kj6Y48WRqVv4N1tRk

$ rad id list

```

This isn't a problem as long as we don't try to accept both. So let's accept

``` ~alice

$ rad id accept 89b2623 -q

$ rad id list

```

Doing so voided the other conflicting revision, and it can no longer be

✓ Target met: 1 seed(s)

🌱 Fetched from z6MknSLrJoTcukLrE435hVNQT4JUhbvWLX4kUzqkEStBU8Vi

$ rad id --repo rad:z42hL2jL4XNk6K8oHQaSWfMgCL7ji

$ rad inspect rad:z42hL2jL4XNk6K8oHQaSWfMgCL7ji --sigrefs

z6MknSLrJoTcukLrE435hVNQT4JUhbvWLX4kUzqkEStBU8Vi [..]

z6Mkt67GdsW7715MEfRuP4pSZxJRJh6kj6Y48WRqVv4N1tRk [..]

``` ~alice

$ rad id list

```

Despite being a delegate, Bob can't edit or redact Alice's revision:

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

│ Title    Define LICENSE for project                                 │

│ Patch    6c61ef1716ad8a5c11e04dd7a3fec51e01fba70b                   │

│ Head     1cc8cd9de8ccc44b4fe3876f2dbd2cd1cf9ddc0e                   │

│ Base     f2de534b5e81d7c6e2dcaf58c3dd91573c0a0354                   │

│ Commits  ahead 2, behind 0                                          │

                let id = term::format::oid(r.id).into();

                let title = term::label(r.title.to_string());

                let (alias, author) =

                let timestamp = term::format::timestamp(r.timestamp).into();

                revisions.push([icon, id, title, alias, author, state, timestamp]);

    let mut signatures = term::Table::<4, _>::default();

    for id in accepted {

        signatures.push([

            term::format::positive("✓").into(),

            id.to_string().into(),

        ]);

    }

    for id in rejected {

        signatures.push([

            term::format::negative("✗").into(),

            id.to_string().into(),

        ]);

    }

    for id in unknown {

        signatures.push([

            term::format::dim("?").into(),

            id.to_string().into(),

        let author = n

            .remote

            .map(|r| {

                alias

            })

            .unwrap_or_default();

                &issue,

                &typed_id.id,

                term::issue::Format::default(),

                profile,

            )?;

        }

Show options

Options

    Show {

        id: Rev,

        format: Format,

    },

    CommentEdit {

        id: Rev,

        let mut edit_comment = None;

        let mut announce = true;

        let mut quiet = false;

        let mut assign_opts = AssignOptions::default();

        let mut label_opts = LabelOptions::default();

        let mut repo = None;

                        _ => anyhow::bail!("unknown format '{val}'"),

                    }

                }

                }

                // Comment options.

            OperationName::Show => Operation::Show {

                id: id.ok_or_else(|| anyhow!("an issue must be provided"))?,

                format,

            },

            OperationName::State => Operation::State {

                id: id.ok_or_else(|| anyhow!("an issue must be provided"))?,

            let signer = term::signer(&profile)?;

            let issue = edit(&mut issues, &repo, id, title, description, &signer)?;

            if !options.quiet {

            }

        }

        Operation::Open {

            let signer = term::signer(&profile)?;

            let issue = issues.create(title, description, &labels, &assignees, [], &signer)?;

            if !options.quiet {

            }

        }

        Operation::Comment {

                term::comment::widget(&comment_id, comment, &profile).print();

            }

        }

            let id = id.resolve(&repo.backend)?;

            let issue = issues

                .get(&id)

                    hint: "reset the cache with `rad issue cache` and try again",

                })?

                .context("No issue with the given ID exists")?;

        }

        Operation::State { id, state } => {

            let signer = term::signer(&profile)?;

        let assigned: String = issue

            .assignees()

            .map(|did| {

                alias.content().to_owned()

            })

        labels.sort();

        let author = issue.author().id;

        table.push([

            match issue.state() {

    )?;

    if !options.quiet {

    }

    Ok(())

}

    -p, --patch                Show the actual patch diff

    -v, --verbose              Show additional information about the patch

Diff options

    Show {

        patch_id: Rev,

        diff: bool,

    },

    Diff {

        patch_id: Rev,

    pub op: Operation,

    pub repo: Option<RepoId>,

    pub announce: bool,

    pub quiet: bool,

    pub authored: bool,

    pub authors: Vec<Did>,

        let mut message = Message::default();

        let mut filter = Some(patch::Status::Open);

        let mut diff = false;

        let mut undo = false;

        let mut reaction: Option<Reaction> = None;

        let mut reply_to: Option<Rev> = None;

                Long("patch") | Short('p') if op == Some(OperationName::Show) => {

                    diff = true;

                }

                }

                // Ready options.

                }

                // Common.

                Long("quiet") | Short('q') => {

                    quiet = true;

                }

            OperationName::Show => Operation::Show {

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

                diff,

            },

            OperationName::Diff => Operation::Diff {

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

            Options {

                op,

                repo,

                quiet,

                announce,

                authored,

        Operation::Show {

            patch_id,

            diff,

        } => {

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

            show::run(

                &patch_id,

                diff,

                &profile,

                &repository,

                workdir.as_ref(),

    let (from, to) = revision.range();

    let stats = common::diff_stats(repository.raw(), &from, &to)?;

    let author = patch.author().id;

    let mut delegates = repository

        .delegates()?

        .into_iter()

pub fn run(

    patch_id: &PatchId,

    diff: bool,

    verbose: bool,

    profile: &Profile,

    stored: &Repository,

        anyhow::bail!("Patch `{patch_id}` not found");

    };

    term::patch::show(&patch, patch_id, verbose, stored, workdir, profile)?;

    if diff {

            .map(|a| a.addr.to_string())

            .unwrap_or_default()

            .into();

        table.push([

            icon.into(),

    profile: &Profile,

) -> term::hstack::HStack<'static> {

    let author = comment.author();

    let (alias, nid) = author.labels();

    term::hstack::HStack::default()

    nid: &'a NodeId,

    alias: Option<Alias>,

    you: bool,

}

impl<'a> Author<'a> {

        let alias = profile.alias(nid);

        Self {

            nid,

            alias,

            you: nid == profile.id(),

        }

    }

    ///   * `(<alias>, <did>)` -- the `Author` is another peer and has an alias

    ///   * `(<blank>, <did>)` -- the `Author` is another peer and has no alias

    pub fn labels(self) -> (term::Label, term::Label) {

        let alias = match self.alias.as_ref() {

            Some(alias) => term::format::primary(alias).into(),

            None => term::Label::blank(),

        };

        (alias, author)

    }

    issue: &issue::Issue,

    id: &cob::ObjectId,

    format: Format,

    profile: &Profile,

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

    let labels: Vec<String> = issue.labels().cloned().map(|t| t.into()).collect();

        .collect();

    let author = issue.author();

    let did = author.id();

    let mut attrs = Table::<2, term::Line>::new(TableOptions {

        spacing: 2,

        *patch.target().head(stored)?,

    )?;

    let author = patch.author();

    let labels = patch.labels().map(|l| l.to_string()).collect::<Vec<_>>();

    let mut attrs = term::Table::<2, term::Line>::new(term::TableOptions {

                Some((

                    merge.timestamp,

                    Update::Merged {

                        merge: merge.clone(),

                    },

                ))

        }));

        updates.sort_by_key(|(t, _)| *t);

        Opened {

            timestamp: patch.timestamp(),

            head: revision.head(),

            updates: updates.into_iter().map(|(_, up)| up).collect(),

                Some((

                    merge.timestamp,

                    Update::Merged {

                        merge: merge.clone(),

                    },

                ))

            }

        } else {

            RevisionEntry::Revised {

                timestamp: revision.timestamp(),

                id,

                head: revision.head(),

                    term::format::default("by").into(),

                ])

                .space()

            }

            Update::Merged { author, merge } => {

                let (alias, nid) = author.labels();