UI polish: keys, backups, wiki, editor, bookmarks, summaries, backdrops ffb67a81188c

-- A proposal comment an AI assistant wrote for the person who asked it

-- (oxygenhub#190): its name, empty for a person's own comment.

ALTER TABLE proposal_comments ADD COLUMN via TEXT NOT NULL DEFAULT '';

{# A repository page's backdrop (oxygenhub#196): its own sky, when the

   handler gave it one. The page marks its content with data-backdrop-avoid. #}

{% if !repo.backdrop.is_empty() %}<script type="application/json" id="backdrop-data">{{ repo.backdrop|safe }}</script>

{% include "backdrop.html" %}{% endif %}

  /* The Markdown editor in GitLab's manner (oxygenhub#193): a Preview tab,

     then icon buttons, fullscreen at the far end, and a footer that says

     Markdown is what it takes. Still a textarea underneath. */

    function svg(d) { return '<svg viewBox="0 0 16 16" width="16" height="16" aria-hidden="true" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round">' + d + '</svg>'; }

    var I = {

      bold: svg('<path d="M4.5 2.5h4.25a2.75 2.75 0 0 1 0 5.5H4.5zM4.5 8h5a2.75 2.75 0 0 1 0 5.5h-5z"/>'),

      italic: svg('<path d="M6.5 2.5h6M3.5 13.5h6M10 2.5l-4 11"/>'),

      strike: svg('<path d="M2.5 8h11M11 4.5c-.5-1.2-1.7-2-3.2-2-1.9 0-3.3 1-3.3 2.6 0 .9.4 1.5 1.2 2M5 11.5c.5 1.2 1.8 2 3.3 2 2 0 3.4-1.1 3.4-2.7"/>'),

      heading: svg('<path d="M3.5 2.5v11M12.5 2.5v11M3.5 8h9"/>'),

      quote: svg('<path d="M2.5 3.5h11M5.5 8h8M5.5 12.5h8M2.5 7v6"/>'),

      code: svg('<path d="M5.5 4.5 2 8l3.5 3.5M10.5 4.5 14 8l-3.5 3.5"/>'),

      link: svg('<path d="M7 9a3 3 0 0 0 4.2.3l2-2a3 3 0 0 0-4.2-4.2l-1 1M9 7a3 3 0 0 0-4.2-.3l-2 2a3 3 0 0 0 4.2 4.2l1-1"/>'),

      ul: svg('<path d="M6 4h7.5M6 8h7.5M6 12h7.5"/><circle cx="2.75" cy="4" r=".75" fill="currentColor"/><circle cx="2.75" cy="8" r=".75" fill="currentColor"/><circle cx="2.75" cy="12" r=".75" fill="currentColor"/>'),

      ol: svg('<path d="M6.5 4h7M6.5 8h7M6.5 12h7M2 2.5h1v3M2 7.5h1.5L2 9.5h1.5M2 10.5h1.5v3H2M2 12h1.5"/>'),

      task: svg('<rect x="2" y="2.5" width="4" height="4" rx=".75"/><path d="m2.75 11 1 1 1.75-2M8.5 4.5h5M8.5 11.5h5"/>'),

      table: svg('<rect x="2" y="2.5" width="12" height="11" rx="1"/><path d="M2 6.5h12M2 10h12M6.5 6.5v7"/>'),

      full: svg('<path d="M2.5 6V2.5H6M10 2.5h3.5V6M13.5 10v3.5H10M6 13.5H2.5V10"/>')

    };

    function b(name, action, title, icon, text) { return { name: name, action: action, title: title, icon: icon ? '<span class="mde-ico">' + icon + '</span>' : undefined, text: text, className: "mde-btn" + (text ? " mde-text" : "") }; }

    function task(ed) {

      var cm = ed.codemirror, from = cm.getCursor("from"), to = cm.getCursor("to");

      for (var l = from.line; l <= to.line; l++) {

        var line = cm.getLine(l), m = line.match(/^(\s*)[-*] \[[ xX]\] /);

        if (m) cm.replaceRange(m[1], { line: l, ch: 0 }, { line: l, ch: m[0].length });

        else cm.replaceRange("- [ ] ", { line: l, ch: (line.match(/^\s*/) || [""])[0].length });

      }

      cm.focus();

    }

    var toolbar = [b("preview", E.togglePreview, "Preview", null, "Preview"), "|",

      b("bold", E.toggleBold, "Bold (Ctrl+B)", I.bold), b("italic", E.toggleItalic, "Italic (Ctrl+I)", I.italic), b("strikethrough", E.toggleStrikethrough, "Strikethrough", I.strike), b("heading", E.toggleHeadingSmaller, "Heading", I.heading), "|",

      b("quote", E.toggleBlockquote, "Quote", I.quote), b("code", E.toggleCodeBlock, "Code", I.code), b("link", E.drawLink, "Link (Ctrl+K)", I.link), "|",

      b("unordered-list", E.toggleUnorderedList, "Bullet list", I.ul), b("ordered-list", E.toggleOrderedList, "Numbered list", I.ol), b("task-list", task, "Task list", I.task), b("table", E.drawTable, "Table", I.table), "|",

      b("fullscreen", E.toggleFullScreen, "Fullscreen", I.full)];

    mds.forEach(function (t) {

      t._mde = new E({ element: t, spellChecker: false, status: false, forceSync: true, autoDownloadFontAwesome: false, toolbar: toolbar,

        placeholder: t.getAttribute("placeholder") || "Write in Markdown…", minHeight: "120px", sideBySideFullscreen: false });

      var c = t._mde.element.parentNode.querySelector(".EasyMDEContainer") || t.nextElementSibling;

      if (c && c.classList.contains("EasyMDEContainer")) {

        var f = document.createElement("div");

        f.className = "mde-foot small mute";

        f.innerHTML = '<span>Markdown supported</span><span class="mde-md" title="Markdown" aria-hidden="true">M↓</span>';

        c.appendChild(f);

      }

    });

        // One repository's own sky (oxygenhub#196): its cluster sits in the

        // wider margin, a little below the middle, even a narrow one, so

        // it never lands on the page's heading or tabs.

        if n == 1 {

            if let Some((x0, x1)) = self.avoid {

                let (l, r) = (x0.max(0.0), (self.w - x1).max(0.0));

                if l.max(r) >= 40.0 && self.w > 0.0 {

                    let cx = if r >= l { x1 + r / 2.0 } else { l / 2.0 };

                    self.clusters[0].fx = cx / self.w;

                    self.clusters[0].fy = 0.6;

                    return;

                }

            }

        }

    }

    #[test]

    fn one_repository_sits_in_the_wider_margin() {

        let repos = vec![Repo { name: "andy/demo".into() }];

        let mut s = Sky::new(&repos, &[], 1400.0, 900.0, false);

        s.resize(1400.0, 900.0, Some((127.0, 1259.0)));

        let (x, y) = s.core(0);

        assert!((x - (1259.0 + 141.0 / 2.0)).abs() < 8.0 && (y - 540.0).abs() < 8.0, "{x} {y}");

            for table in ["proposal_reviews", "proposal_comments"] {

                sqlx::query(&format!("UPDATE {table} SET via = ? WHERE via = ?")).bind(new).bind(old).execute(pool).await?;

            }

            for table in ["proposal_reviews", "proposal_comments"] {

                sqlx::query(&format!("UPDATE {table} SET via = ? WHERE via = ? AND {in_org}"))

                    .bind(new)

                    .bind(old)

                    .bind(owner_hint)

                    .execute(pool)

                    .await?;

            }

            for table in ["proposal_reviews", "proposal_comments"] {

                sqlx::query(&format!("UPDATE {table} SET via = ? WHERE via = ? AND {in_repo}"))

                    .bind(new)

                    .bind(old)

                    .bind(id)

                    .execute(pool)

                    .await?;

            }

    let user = review_context(row, p, &loaded, budget.saturating_sub(system.chars().count()));

    ask(app, a, &system, &user).await

}

// -------------------------------------------------------- summaries

/// The system prompt for a summary posted as a comment (oxygenhub#190).

pub fn summary_system_prompt(a: &Assistant, site: &str, prompts: &str) -> String {

    let mut s = format!(

        "You are {name}, an AI assistant working on {site}, an OxygenHub site, with a next-generation version control system \

         called Oxygen (its command is oxy). A proposal is Oxygen's equivalent of a merge request or pull request. \

         Please summarise the proposal and comment on it. A person asked for this; it is posted as a comment made via you, \

         under their name. Answer in Markdown: a short summary of what the proposal changes and why, then anything a reviewer \

         should look at closely; keep to what the description and the diff show.",

        name = a.name

    );

    if !prompts.trim().is_empty() {

        s.push_str("\n\n");

        s.push_str(prompts.trim());

    }

    s

}

/// Ask `a` to summarise proposal `p` for `by`: like [`request_review`],

/// but the answer is a conversation comment via the assistant.

pub async fn request_summary(

    app: &Shared,

    row: &crate::db::repos::RepoRow,

    p: &crate::db::proposals::ProposalRow,

    by: &crate::db::accounts::Account,

    a: Assistant,

) -> Result<(), String> {

    app.assistant_gate.lock().unwrap_or_else(|e| e.into_inner()).take(row.id, p.id, &a.name)?;

    let pool = &app.db;

    crate::db::proposals::add_event(pool, p.id, &by.username, &format!("asked {} for a summary", a.name), "").await.ok();

    crate::db::accounts::audit(

        pool,

        Some(by),

        "assistant.asked",

        &format!("{}/{}", row.owner, row.name),

        &format!("{} #{} summary", a.name, p.number),

    )

    .await

    .ok();

    let (app, row, p, by) = (app.clone(), row.clone(), p.clone(), by.clone());

    tokio::spawn(async move {

        let outcome = answer_summary(&app, &row, &p, &a).await;

        app.assistant_gate.lock().unwrap_or_else(|e| e.into_inner()).release(p.id, &a.name);

        match outcome {

            Ok(body) => {

                crate::db::proposals::add_comment_via(&app.db, p.id, by.id, &by.username, &body, &a.name).await.ok();

            }

            Err(why) => {

                crate::db::proposals::add_event(&app.db, p.id, &by.username, &format!("{} did not answer", a.name), &why).await.ok();

            }

        }

    });

    Ok(())

}

async fn answer_summary(

    app: &Shared,

    row: &crate::db::repos::RepoRow,

    p: &crate::db::proposals::ProposalRow,

    a: &Assistant,

) -> Result<String, String> {

    let repo = crate::repos::names::RepoName::new(&row.owner, &row.name).ok_or("bad repository name")?;

    let loaded = crate::web::proposals::load(app, &repo, p.clone()).await.map_err(|e| format!("the proposal could not be loaded: {e}"))?;

    let budget = usize::try_from(a.budget).unwrap_or(DEFAULT_BUDGET as usize).max(1_000);

    let prompts = prompt_for_repo(&app.db, row).await.map_err(|e| e.to_string())?;

    let system = summary_system_prompt(a, &app.config.site.name, &prompts);

    /// The AI assistant that wrote it for the author (migration 0066),

    /// empty for the author's own comment.

    #[sqlx(default)]

    pub via: String,

    .fetch_one(pool)

    .await?;

    touch(pool, proposal_id).await?;

    Ok(row)

}

/// A conversation comment an AI assistant (`via`) wrote for `author`,

/// who asked it.

pub async fn add_comment_via(

    pool: &Pool,

    proposal_id: i64,

    author_id: i64,

    author: &str,

    body: &str,

    via: &str,

) -> sqlx::Result<CommentRow> {

    let row = sqlx::query_as(

        "INSERT INTO proposal_comments (proposal_id, author_id, author, body, path, anchor_change, anchor_index, created_ms, via) VALUES (?, ?, ?, ?, '', '', 0, ?, ?) RETURNING *",

    )

    .bind(proposal_id)

    .bind(author_id)

    .bind(author)

    .bind(body)

    .bind(now_ms())

    .bind(via)

/// The overview of `shown` (a bookmark or tag; the default bookmark

/// unless the viewer chose another, oxygenhub#191).

pub fn overview(repo: &Repo, cache: &StateCache, default_bookmark: &str, shown: &str) -> Result<Overview> {

    let target = match resolve(repo, cache, shown) {

        Err(_) => RefTarget { label: shown.into(), kind: RefKind::Bookmark, heads: vec![] },

/// One repository's sky (#196): the backdrop of its own pages, from the

/// database only, with no live polling. Empty when it cannot be read.

pub(crate) async fn repo_sky(app: &Shared, row: &db::repos::RepoRow) -> String {

    let now = db::now_ms();

    match db::activity::sky(&app.db, &[row.id], now - SKY_DAYS * 86_400_000, SKY_EVENTS).await {

        Ok(events) => sky_json(std::slice::from_ref(row), &events, now, ""),

        Err(_) => String::new(),

    }

}

    /// The backdrop's data, a sky of this repository alone; empty for none

    /// (docs/backgrounds.md, oxygenhub#196).

    pub backdrop: String,

            backdrop: String::new(),

    /// Give the page a backdrop: this repository's sky, its activity of the

    /// last 30 days from the database (#196).

    pub async fn with_sky(mut self, app: &Shared, row: &db::repos::RepoRow) -> RepoShell {

        self.backdrop = home::repo_sky(app, row).await;

        self

    }

        repo: RepoShell::new(app, &row, "proposals").with_role(role).with_sky(app, &row).await,

    /// `summary` asks for a summary comment (oxygenhub#190); otherwise a review.

    #[serde(default)]

    task: String,

    let summary = f.task == "summary";

    let asked = if summary {

        crate::assistants::request_summary(&app, &row, &p, &me.account, a).await

    } else {

        crate::assistants::request_review(&app, &row, &p, &me.account, a).await

    };

    match asked {

            Some(if summary {

                format!("Asked {who} for a summary; its comment appears here when it comes.")

            } else {

                format!("Asked {who} to review; its answer appears here when it comes.")

            }),

    Ok(Page(ConflictsPage { shell, repo: RepoShell::new(&app, &row, "conflicts").with_role(role).with_sky(&app, &row).await, conflicts }))

    /// The bookmark or tag shown: the default unless `?at=` chose another

    /// (#191).

    at: String,

#[derive(Deserialize)]

pub struct OverviewQuery {

    at: Option<String>,

}

    Query(q): Query<OverviewQuery>,

    let at = q.at.map(|a| a.trim().to_string()).filter(|a| !a.is_empty()).unwrap_or_else(|| default.clone());

    let shown = at.clone();

    let mut o = app

        .repos

        .read(&repo, move |r, cache| view::overview(r, cache, &default, &shown))

        .await

        .map_err(|e| Error::from_repo(shell.clone(), e))?;

    let rs = RepoShell::new(&app, &row, "code").with_role(role).with_sky(&app, &row).await;

        at,

pub async fn tree_root(Path((owner, name, r)): Path<(String, String, String)>) -> Response {

    // A bookmark's or tag's root is the overview with it chosen, side bar

    // and all (#191).

    axum::response::Redirect::to(&format!("/{owner}/{name}?at={}", super::settings::urlencode(&r))).into_response()

    /// Every page's slug, for the side bar (#194).

    pages: Vec<String>,

    /// How many changes touched this page.

    revisions: usize,

    /// The page's headings: (level, text, id).

    toc: Vec<(u8, String, String)>,

    let pages: Vec<String> = wiki::pages(&app, &repo).await.map_err(e)?.into_iter().filter(|p| p != wiki::SIDEBAR).collect();

    let any = !pages.is_empty();

    let history = if text.is_some() { wiki::history(&app, &repo, &slug, 1000).await.map_err(e)? } else { vec![] };

    let revisions = history.len();

    let last = history.into_iter().next();

    let rs = RepoShell::new(&app, &row, "wiki").with_role(role).with_sky(&app, &row).await;

    let (html, toc) = match text.as_deref().map(|t| contents(&render(&owner, &name, t))) {

        Some((h, t)) => (Some(h), t),

        None => (None, vec![]),

    };

        html,

        pages,

        revisions,

        toc,

/// Give a rendered page's `<h1>`–`<h3>` ids and list them, for the

/// table of contents (#194). The HTML is already sanitised; the ids are

/// made of letters, digits and dashes only, and the text keeps only what

/// was between the tags.

fn contents(html: &str) -> (String, Vec<(u8, String, String)>) {

    let mut out = String::with_capacity(html.len() + 64);

    let mut toc = vec![];

    let mut used = std::collections::HashSet::new();

    let mut rest = html;

    while let Some(at) = rest.find("<h") {

        let level = rest.as_bytes().get(at + 2).copied().unwrap_or(0);

        let tagged = matches!(level, b'1'..=b'3') && rest[at + 3..].starts_with('>');

        let close = format!("</h{}>", level as char);

        let end = if tagged { rest[at..].find(&close).map(|e| at + e) } else { None };

        let Some(end) = end else {

            out.push_str(&rest[..at + 2]);

            rest = &rest[at + 2..];

            continue;

        };

        let inner = &rest[at + 4..end];

        let mut text = String::new();

        let mut in_tag = false;

        for c in inner.chars() {

            match c {

                '<' => in_tag = true,

                '>' => in_tag = false,

                c if !in_tag => text.push(c),

                _ => {}

            }

        }

        let mut id: String = text

            .replace("&", "and")

            .chars()

            .map(|c| if c.is_alphanumeric() { c.to_ascii_lowercase() } else { '-' })

            .collect::<String>()

            .split('-')

            .filter(|p| !p.is_empty())

            .collect::<Vec<_>>()

            .join("-");

        if id.is_empty() {

            id = "section".into();

        }

        let mut unique = id.clone();

        let mut n = 1;

        while !used.insert(unique.clone()) {

            n += 1;

            unique = format!("{id}-{n}");

        }

        out.push_str(&rest[..at]);

        out.push_str(&format!("<h{l} id=\"{unique}\">{inner}{close}", l = level as char));

        toc.push((level - b'0', text.trim().to_string(), unique));

        rest = &rest[end + close.len()..];

    }

    out.push_str(rest);

    (out, toc)

}

}

#[cfg(test)]

mod tests {

    #[test]

    fn headings_get_ids_and_a_contents_list() {

        let (html, toc) = super::contents("<h1>R* API</h1><p>x</p><h2>Build &amp; run</h2><h2>Build &amp; run</h2><h4>deep</h4><hr>");

        assert_eq!(

            html,

            "<h1 id=\"r-api\">R* API</h1><p>x</p><h2 id=\"build-and-run\">Build &amp; run</h2><h2 id=\"build-and-run-2\">Build &amp; run</h2><h4>deep</h4><hr>"

        );

        assert_eq!(

            toc.iter().map(|t| (t.0, t.2.as_str())).collect::<Vec<_>>(),

            [(1, "r-api"), (2, "build-and-run"), (2, "build-and-run-2")]

        );

    }

    // A ref's root is the overview with it chosen, side bar and all (#191).

    assert_eq!(get(&h.app, "/andy/demo/tree/v0.1").await.0, StatusCode::SEE_OTHER);

    let at_tag = page(&h.app, "/andy/demo?at=v0.1").await;

    assert!(at_tag.contains("README.md") && at_tag.contains("class=\"ref-pick\"") && at_tag.contains("side cards"), "{at_tag}");

    assert!(at_tag.contains("href=\"/andy/demo?at=v0.1\" class=\"on\""), "the tag is the one chosen");

    assert!(page(&h.app, &format!("/andy/demo?at={}", &c1[..10])).await.contains("README.md"));

    let tree = send(app, "GET", "/andy/demo?at=main", None, None).await.body;

        home.contains("Welcome")

            && home.contains("href=\"/andy/demo/wiki/Guide\"")

            && home.contains("Andy McCall via")

            && home.contains("edited this page")

            && home.contains("1 revision"),

    assert!(home.contains("<h1 id=\"docs\">Docs</h1>") && home.contains("href=\"/andy/docs/wiki/Overview\""), "{home}");

    // Bob asks Claude for a summary (#190): it comes as a comment via Claude.

    assert!(page.contains("Summarise with Claude"), "{page}");

    seen.lock().unwrap().clear();

    let page = get(app, "/andy/demo/proposal/1", Some(&bob)).await.body;

    let r =

        act(app, "/andy/demo/proposal/1/assistant", Some(&bob), &format!("_csrf={}&assistant=Claude&task=summary", csrf_of(&page))).await;

    assert!(r.body.contains("Asked Claude for a summary"), "{}", r.body);

    let mut comments = vec![];

    for _ in 0..100 {

        comments = db::proposals::comments(&app.db, 1).await.unwrap();

        if comments.iter().any(|c| c.via == "Claude") {

            break;

        }

        tokio::time::sleep(std::time::Duration::from_millis(100)).await;

    }

    let summary = comments.iter().find(|c| c.via == "Claude").expect("the assistant's summary arrived");

    assert_eq!(summary.author, "bob");

    assert!(summary.body.contains("Adds a third line"));

    {

        let calls = seen.lock().unwrap();

        assert_eq!(calls.len(), 1);

        let c = &calls[0];

        assert!(

            c.contains("called Oxygen")

                && c.contains("equivalent of a merge request or pull request")

                && c.contains("Please summarise the proposal"),

            "{c}"

        );

        assert!(c.contains("Review for correctness first.") && c.contains("+three"), "the site's prompt and the context: {c}");

    }

    let page = get(app, "/andy/demo/proposal/1", Some(&andy)).await.body;

    assert!(page.contains("asked Claude for a summary") && page.contains("wrote this for bob"), "{page}");

| A repository's overview, wiki, proposals and Conflicts tab | **Its sky** | Your sky's scene for that repository alone: its activity of the last 30 days, from the database (#196) |

| Settings › Keys, Tokens and Backups | **The mark** | As on sign-in: brand only, no data (#196) |

**Never:** file, blame and diff pages, the editor, issues and proposals

while being written, and admin tables. Those pages are for reading

closely, and motion behind them costs attention.

On 2026-10-14 Andy chose to give backdrops to the pages of that day's

polish batch as well (#196): a repository's overview, wiki, proposals

and Conflicts tab, and Settings › Keys, Tokens and Backups. They keep the

rules above: the content is opaque and marked `data-backdrop-avoid`, so

a scene shows only in the margins, and anyone can turn backdrops off.

<script type="application/json" id="backdrop-data">{"scene":"mark"}</script>

{% include "backdrop.html" %}

<div data-backdrop-avoid>

</div>

    <a class="go primary" href="/new" title="New repository">+ NEW</a>

{% include "repo_backdrop.html" %}

<div data-backdrop-avoid>

</div>

{% block bodyattrs %} data-repo="{{ repo.url }}" data-ref="{{ at }}"{% endblock %}

{% include "repo_backdrop.html" %}

<div data-backdrop-avoid>

    {% if o.heads > 1 %}<div class="strip warn">{{ at }} has {{ o.heads }} heads; the tree below is their union. <a href="{{ repo.url }}/bookmarks">Bookmarks</a></div>{% endif %}

      <details class="ref-pick">

        <summary class="go small" aria-haspopup="true" title="Choose a bookmark or tag"><span aria-hidden="true">{% if o.tree.target.kind == crate::repos::view::RefKind::Tag %}🏷{% else %}◆{% endif %}</span> {{ at }} <span aria-hidden="true">▾</span></summary>

        <div class="ref-panel" role="menu">

          <p class="small mute">Bookmarks</p>

          <ul class="plain">{% for b in o.bookmarks %}<li><a role="menuitem" href="{{ repo.url }}{% if b.name != repo.default_bookmark %}?at={{ b.name|urlencode }}{% endif %}"{% if b.name == at %} class="on"{% endif %}>◆ {{ b.name }}{% if b.name == repo.default_bookmark %} <span class="tag">default</span>{% endif %}</a></li>{% endfor %}</ul>

          {% if !o.tags.is_empty() %}<p class="small mute">Tags</p>

          <ul class="plain">{% for t in o.tags %}<li><a role="menuitem" href="{{ repo.url }}?at={{ t.name|urlencode }}"{% if t.name == at %} class="on"{% endif %}>🏷 {{ t.name }}</a></li>{% endfor %}</ul>{% endif %}

          <p class="small"><a href="{{ repo.url }}/bookmarks">All bookmarks ›</a></p>

        </div>

      </details>

      {% if o.latest.is_none() %}<a class="go small" href="{{ repo.url }}/changes/{{ at }}">{{ o.changes|plural("change", "changes") }}</a>{% endif %}

      {% if repo.can(crate::auth::Access::Write) %}<a class="go small" href="{{ repo.url }}/newfile/{{ at }}">new file</a>{% endif %}

          <a class="download" href="{{ repo.url }}/archive?ref={{ at|urlencode }}&amp;format=zip" download><span aria-hidden="true">⤓</span> Download ZIP</a>

          <p class="small mute">{{ at }} as it is now, without its history. Also as <a href="{{ repo.url }}/archive?ref={{ at|urlencode }}&amp;format=tar.zst" download>.tar.zst</a>.</p>

      <span class="tree-meta"><a href="{{ repo.url }}/change/{{ c.hash }}"><code>{{ c.short }}</code></a><time class="ago" title="{{ c.when_ms|when }}">{{ c.when_ms|ago }}</time><a class="hist" href="{{ repo.url }}/changes/{{ at }}">{{ crate::web::icons::svg("history")|safe }} {{ o.changes|plural("change", "changes") }}</a></span>

    {% if let Some(l) = o.license %}<p class="small">Licence: <a href="{{ repo.url }}/file/{{ at }}/{{ l }}">{{ l }}</a></p>{% endif %}

    <ul class="plain bookmarks">{% for b in o.recent_bookmarks() %}<li><a href="{{ repo.url }}?at={{ b.name|urlencode }}" title="{{ b.name }}">{{ b.name }}</a>{% if b.heads.len() > 1 %}<span class="tag warn">{{ b.heads.len() }} heads</span>{% endif %}{% if b.conflicted %}<span class="tag bad">conflicts</span>{% endif %}<time class="small mute" title="{{ b.latest_ms|when }}">{{ b.latest_ms|ago }}</time></li>{% endfor %}</ul>

    {% if o.tags.is_empty() %}<p class="mute small">None.</p>{% else %}<ul class="plain">{% for t in o.tags %}<li><a href="{{ repo.url }}?at={{ t.name|urlencode }}">{{ t.name }}</a>{% if t.signer.is_some() %} <span class="sig sig-valid" title="signed">✔</span>{% endif %}</li>{% endfor %}</ul>{% endif %}

</div>

{% include "repo_backdrop.html" %}

<div data-backdrop-avoid>

      <div class="tl-head"><a href="/{{ c.row.author }}"><strong>{{ c.row.author }}</strong></a>{% if !c.row.via.is_empty() %} <span class="mute" aria-hidden="true">↳</span> <span class="tag" title="An AI assistant wrote this for {{ c.row.author }}, who asked it">agent</span> <img class="avatar xs" src="/avatar/agent/{{ c.row.via }}" alt="" width="16" height="16"> <strong>{{ c.row.via }}</strong>{% endif %} commented <time title="{{ c.row.created_ms|when_i }}">{{ c.row.created_ms|ago_i }}</time></div>

    {% if !assistants.is_empty() %}<div class="side-assist">{% for a in assistants %}<form class="tiny inline" method="post" action="{{ repo.url }}/proposal/{{ p.number }}/assistant"><input type="hidden" name="_csrf" value="{{ shell.csrf }}"><input type="hidden" name="assistant" value="{{ a }}"><button type="submit" class="agent-btn" title="Ask {{ a }}, an AI assistant, to review; its answer is recorded as your review via {{ a }}"><img src="/avatar/agent/{{ a }}" alt="" width="16" height="16"> Ask {{ a }}</button> <button type="submit" class="agent-btn" name="task" value="summary" title="{{ a }}, an AI assistant, summarises the proposal; its summary is posted as your comment via {{ a }}"><img src="/avatar/agent/{{ a }}" alt="" width="16" height="16"> Summarise with {{ a }}</button></form>{% endfor %}</div>{% endif %}

</div>

<script type="application/json" id="backdrop-data">{"scene":"mark"}</script>

{% include "backdrop.html" %}

<div data-backdrop-avoid>

<form class="card wide keys-verify" method="post" action="/settings/keys/verify">

<section class="card-box">

  <div class="card-head"><h2>Linked keys</h2><span class="count-chip">{{ keys.len() }}</span></div>

  {% if keys.is_empty() %}<p class="empty small">No keys linked yet.</p>{% else %}

  <ul class="rows token-rows">

  {% for k in keys %}

    <li>

      <div class="token-main">

        <div class="token-name"><code>{{ k.key|short }}</code> <strong>{{ k.name }}</strong> <span class="mute">{{ k.email }}</span></div>

        <div class="small mute">linked <time title="{{ k.linked_ms|when_i }}">{{ k.linked_ms|ago_i }}</time></div>

      </div>

      <div class="token-actions">

        <form class="inline" method="post" action="/settings/keys/unlink"><input type="hidden" name="_csrf" value="{{ shell.csrf }}"><input type="hidden" name="key" value="{{ k.key }}"><button class="small danger" title="Changes it signs stop counting as yours">Unlink</button></form>

      </div>

    </li>

  {% endfor %}

  </ul>

  {% endif %}

</section>

<section class="card-box">

  <div class="card-head"><h2>Link a key</h2></div>

  <form class="pad token-form" method="post" action="/settings/keys/upload" enctype="multipart/form-data">

    <input type="hidden" name="_csrf" value="{{ shell.csrf }}">

    <label for="identity">Identity file (from <code>oxy identity export</code>)</label><input type="file" id="identity" name="identity" required>

    <button type="submit">UPLOAD</button>

  </form>

</section>

</div>

<script type="application/json" id="backdrop-data">{"scene":"mark"}</script>

{% include "backdrop.html" %}

<div data-backdrop-avoid>

</div>

/* Settings › Keys (oxygenhub#188) shares the token rows; Backups' form is as wide as its Runs (#189). */

form.card.keys-verify { max-width: none; }

form.card.backup-form { max-width: none; }

/* Wiki clone box (oxygenhub#192): the command wraps inside its card. */

.side-sec pre.snippet { white-space: pre-wrap; overflow-wrap: anywhere; margin: 0; }

/* The overview's bookmark and tag picker (oxygenhub#191). */

details.ref-pick { position: relative; }

details.ref-pick > summary { list-style: none; cursor: pointer; }

details.ref-pick > summary::-webkit-details-marker { display: none; }

.ref-panel { position: absolute; z-index: 30; top: calc(100% + 4px); left: 0; min-width: 240px; max-width: min(360px, 90vw); max-height: 60vh; overflow: auto; background: var(--panel); border: 1px solid var(--line); border-radius: 6px; box-shadow: 0 8px 24px rgba(0,0,0,.15); padding: 8px 0; }

.ref-panel p { margin: 4px 12px; }

.ref-panel ul { margin: 0; }

.ref-panel li a { display: block; padding: 4px 12px; overflow-wrap: anywhere; }

.ref-panel li a:hover, .ref-panel li a.on { background: var(--soft); text-decoration: none; }

.ref-panel li a.on { font-weight: 600; }

/* The Markdown editor in GitLab's manner (oxygenhub#193): one bordered box,

   a Preview tab, icon buttons, a footer. */

.EasyMDEContainer { border: 1px solid var(--line); border-radius: 6px; background: var(--bg); overflow: hidden; }

.EasyMDEContainer:focus-within { border-color: var(--acc); box-shadow: 0 0 0 2px color-mix(in srgb, var(--acc) 25%, transparent); }

.EasyMDEContainer .editor-toolbar { display: flex; flex-wrap: wrap; align-items: center; gap: 2px; border: 0; border-bottom: 1px solid var(--line); border-radius: 0; background: var(--panel); padding: 4px 6px; }

.EasyMDEContainer .editor-toolbar i.separator { border-left: 1px solid var(--line); border-right: 0; height: 18px; margin: 0 4px; }

.EasyMDEContainer .editor-toolbar button.mde-btn { border: 0; background: transparent; display: inline-flex; align-items: center; justify-content: center; width: 30px; height: 28px; padding: 0; border-radius: 6px; color: var(--mute); }

.EasyMDEContainer .editor-toolbar button.mde-btn.mde-text { width: auto; padding: 0 10px; font-size: 13px; font-weight: 500; color: var(--ink); }

.EasyMDEContainer .editor-toolbar button.mde-btn:hover, .EasyMDEContainer .editor-toolbar button.mde-btn.active { background: var(--soft); color: var(--ink); }

.EasyMDEContainer .editor-toolbar button.fullscreen { margin-left: auto; }

.EasyMDEContainer .editor-toolbar .mde-ico { display: inline-flex; }

.EasyMDEContainer .CodeMirror { border: 0; border-radius: 0; font-family: ui-monospace, SFMono-Regular, Menlo, Consolas, monospace; font-size: 13px; }

.EasyMDEContainer .CodeMirror .CodeMirror-placeholder { color: var(--mute); }

.EasyMDEContainer .editor-preview { background: var(--bg); color: var(--ink); }

.mde-foot { display: flex; justify-content: space-between; align-items: center; padding: 4px 10px; border-top: 1px solid var(--line); background: var(--panel); }

.mde-md { font-weight: 700; border: 1px solid currentColor; border-radius: 3px; padding: 0 3px; font-size: 10px; }

.EasyMDEContainer .editor-toolbar.fullscreen, .EasyMDEContainer .CodeMirror-fullscreen, .EasyMDEContainer .editor-preview-active-side { background: var(--bg); }

/* Wiki pages (oxygenhub#194): a title row with who edited it and the

   buttons, the page as a card, pages and contents in the side bar. */

.wiki-top { display: flex; flex-wrap: wrap; align-items: flex-start; justify-content: space-between; gap: 12px; padding-bottom: 12px; margin-bottom: 16px; border-bottom: 1px solid var(--line); }

.wiki-title { min-width: 0; }

.wiki-title h1 { margin: 0 0 4px; text-wrap: balance; }

.wiki-title p { margin: 0; }

.wiki-actions { display: flex; gap: 8px; flex-shrink: 0; }

article.wiki-doc.card-doc { border: 1px solid var(--line); border-radius: 6px; background: var(--panel); padding: 20px 28px; }

.wiki-foot { margin-top: 8px; }

.wiki-side-col .side-sec { min-width: 0; }

details.wiki-pages > summary { list-style: none; cursor: pointer; }

details.wiki-pages > summary::-webkit-details-marker { display: none; }

details.wiki-pages > summary h3::before { content: "▸ "; color: var(--mute); }

details.wiki-pages[open] > summary h3::before { content: "▾ "; }

.wiki-pages ul, .wiki-toc { margin: 0; padding: 6px 12px; }

.wiki-pages li a, .wiki-toc li a { display: block; padding: 2px 0; overflow-wrap: anywhere; }

.wiki-pages li a.on { font-weight: 600; }

.wiki-pages p { margin: 0 12px 8px; }

.wiki-toc li.lv2 { padding-left: 12px; }

.wiki-toc li.lv3 { padding-left: 24px; font-size: 13px; }

.wiki-side-col .clone { display: flex; gap: 6px; padding: 8px 12px; }

.wiki-side-col .clone input { flex: 1; min-width: 0; font-family: ui-monospace, SFMono-Regular, Menlo, Consolas, monospace; font-size: 12px; }

.wiki-doc h1[id], .wiki-doc h2[id], .wiki-doc h3[id] { scroll-margin-top: 16px; }

.EasyMDEContainer .editor-toolbar button.mde-btn.mde-text, .EasyMDEContainer .editor-toolbar button.mde-btn.mde-text::first-letter { text-transform: none; }

{% include "repo_backdrop.html" %}

<div data-backdrop-avoid>

<div class="wiki-top">

  <div class="wiki-title">

    <h1>{{ title }}</h1>

    {% if let Some(c) = last %}<p class="small mute">{{ c.author.name }}{% if let Some(v) = c.via %} via {{ v.name }}{% endif %} edited this page <time title="{{ c.when_ms|when_i }}">{{ c.when_ms|ago_i }}</time> · <a href="{{ repo.url }}/wiki/{{ slug }}/history">{{ revisions|plural("revision", "revisions") }}</a></p>{% endif %}

  </div>

  <div class="wiki-actions">

    {% if can_edit %}{% if html.is_some() %}<a class="go" href="{{ repo.url }}/wiki/{{ slug }}/edit">Edit</a>{% endif %}<a class="go primary" href="{{ repo.url }}/wiki/_new">New page</a>{% endif %}

  </div>

</div>

  <article class="doc wiki-doc card-doc">{{ h|safe }}</article>

  {% if can_edit %}<p class="small mute wiki-foot"><form class="tiny inline" method="post" action="{{ repo.url }}/wiki/{{ slug }}/delete" onsubmit="return confirm('Delete the page {{ title }}?')"><input type="hidden" name="_csrf" value="{{ shell.csrf }}"><button class="linkish">Delete this page</button></form></p>{% endif %}

<aside class="side side-sections wiki-side-col">

  {% if any %}<section class="side-sec">

    <details class="wiki-pages"{% if sidebar.is_none() %} open{% endif %}><summary class="side-head"><h3>Pages <span class="count-chip">{{ pages.len() }}</span></h3></summary>

      <ul class="plain">{% for p in pages %}<li><a href="{{ repo.url }}/wiki/{{ p }}"{% if *p == slug %} class="on"{% endif %}>{{ crate::wiki::title_of(p) }}</a></li>{% endfor %}</ul>

      <p class="small"><a href="{{ repo.url }}/wiki/_pages">Search the pages ›</a></p>

    </details>

  </section>{% endif %}

  {% if toc.len() > 1 %}<section class="side-sec"><div class="side-head"><h3>Contents</h3></div>

    <ul class="plain wiki-toc">{% for (level, text, id) in toc %}<li class="lv{{ level }}"><a href="#{{ id }}">{{ text|safe }}</a></li>{% endfor %}</ul>

  </section>{% endif %}

  <section class="side-sec"><div class="side-head"><h3>Clone this wiki</h3></div>

    <div class="clone"><input type="text" readonly value="oxy clone {{ shell.base_url }}/{{ repo.owner }}/{{ repo.name }}.wiki" onfocus="this.select()" onclick="this.select()" aria-label="Clone command"><button type="button" class="small" data-copy="oxy clone {{ shell.base_url }}/{{ repo.owner }}/{{ repo.name }}.wiki">copy</button></div>

  </section>

</div>