@join-pantheon/cli 0.24.1 → 0.25.0

package/helper/macos/menubar.swift

@@ -10,12 +10,18 @@
  * truth and this file never grows business logic. No network of its own, no
  * state of its own, no credentials — it cannot leak what it never holds.
  *
+ * The menu is also the daily review surface: every open thing — decisions for
+ * this human, what their side owes teammates, what teammates owe them — is a
+ * row with a copy button, and opens a centred panel with the whole text and the
+ * actions that settle it. Before that it was a status light that said "no
+ * decisions need your input" and left nothing to look at.
+ *
  *   pantheon-tray <absolute-path-to-pantheon> [poll-seconds]
  */
 import AppKit
 
 let argv = CommandLine.arguments
-if argv.count == 2, argv[1] == "version" { print("1"); exit(0) }
+if argv.count == 2, argv[1] == "version" { print("2"); exit(0) }
 guard argv.count >= 2 else {
   fputs("usage: pantheon-tray <path-to-pantheon> [poll-seconds]\n", stderr)
   exit(64)
@@ -43,9 +49,51 @@ struct TrayState {
   var surfaceBundleID = ""
   var decisionsPrompt = ""
   var decisions: [(id: String, body: String, detail: String, prompt: String)] = []
+  var items: [Item] = []
   var version = ""
 }
 
+/// One open thing, as the menu shows it and the panel expands it.
+struct Item {
+  let id: String
+  let kind: String          // decision | owed | waiting
+  let title: String
+  let headline: String
+  let detail: String
+  let prompt: String
+  let who: String           // member id, or "you"
+  let when: Double          // ms since epoch
+  let goal: String
+  let ref: String
+  let space: String
+
+  var isDecision: Bool { kind == "decision" }
+  var heading: String {
+    switch kind {
+    case "decision": return "Needs your decision"
+    case "owed": return "Your side owes this"
+    default: return "Waiting on \(who)"
+    }
+  }
+  /// "praneet · 2d ago · pantheon"
+  var subtitle: String {
+    var parts: [String] = []
+    // Who is asking, on every kind. A decision row used to say only "11h ago",
+    // which is the one fact a reader could already guess.
+    if kind == "owed" { parts.append("you owe") } else if !who.isEmpty { parts.append(who) }
+    if when > 0 { parts.append(Item.age(when)) }
+    if !space.isEmpty { parts.append(space) }
+    return parts.joined(separator: " · ")
+  }
+  static func age(_ ms: Double) -> String {
+    let secs = max(0, Date().timeIntervalSince1970 - ms / 1000)
+    if secs < 90 { return "just now" }
+    if secs < 5400 { return "\(Int(secs / 60))m ago" }
+    if secs < 172_800 { return "\(Int(secs / 3600))h ago" }
+    return "\(Int(secs / 86_400))d ago"
+  }
+}
+
 /// Run a command with a hard timeout. The menu bar must never beachball
 /// because a laptop's relay is asleep — tray-status has its own network
 /// timeouts, this bounds the whole process as the backstop.
@@ -88,6 +136,21 @@ func fetchState() -> TrayState {
   s.surfaceName = j["surface_name"] as? String ?? "agent"
   s.surfaceBundleID = j["surface_bundle_id"] as? String ?? ""
   s.decisionsPrompt = j["decisions_prompt"] as? String ?? ""
+  for i in (j["items"] as? [[String: Any]] ?? []) {
+    s.items.append(Item(
+      id: i["id"] as? String ?? "",
+      kind: i["kind"] as? String ?? "decision",
+      title: i["title"] as? String ?? "",
+      headline: i["headline"] as? String ?? i["title"] as? String ?? "",
+      detail: i["detail"] as? String ?? i["title"] as? String ?? "",
+      prompt: i["prompt"] as? String ?? "",
+      who: i["who"] as? String ?? "",
+      when: (i["when"] as? Double) ?? Double(i["when"] as? Int ?? 0),
+      goal: i["goal"] as? String ?? "",
+      ref: i["ref"] as? String ?? "",
+      space: i["space"] as? String ?? ""
+    ))
+  }
   for d in (j["decisions"] as? [[String: Any]] ?? []) {
     s.decisions.append((
       id: d["id"] as? String ?? "",
@@ -99,6 +162,139 @@ func fetchState() -> TrayState {
   return s
 }
 
+
+/**
+ * One open thing, as a menu row: title, a dim second line, and a copy control on
+ * the right. Clicking the row opens the detail panel; clicking the copy glyph
+ * puts the agent prompt on the clipboard and LEAVES THE MENU OPEN, so a person
+ * reviewing four things can take all four without reopening the menu each time.
+ *
+ * Drawn by hand rather than assembled from controls: a menu runs its own event
+ * loop, and hit-testing two zones in one view is far more predictable there than
+ * nesting buttons inside an NSMenuItem.
+ */
+final class RowView: NSView {
+  private let item: Item
+  private let onOpen: (Item) -> Void
+  private let onCopy: (Item) -> Void
+  private var hovering = false
+  private var overCopy = false
+  private var copied = false
+
+  private let titleLines: Int
+  private static let titleFont = NSFont.systemFont(ofSize: 13, weight: .medium)
+  private static let lineHeight: CGFloat = 17
+
+  /// How many lines this title needs, at most two. A one-line row truncated
+  /// mid-word ("Sid asked: Sid is asking: is this work in producti…") hid the
+  /// only part worth reading; two lines carry almost every real title whole.
+  static func lines(for text: String, width: CGFloat) -> Int {
+    let para = NSMutableParagraphStyle()
+    para.lineBreakMode = .byWordWrapping
+    let h = (text as NSString).boundingRect(
+      with: NSSize(width: width, height: .greatestFiniteMagnitude),
+      options: [.usesLineFragmentOrigin, .usesFontLeading],
+      attributes: [.font: titleFont, .paragraphStyle: para]).height
+    return max(1, min(2, Int(ceil(h / lineHeight))))
+  }
+
+  init(item: Item, width: CGFloat, onOpen: @escaping (Item) -> Void, onCopy: @escaping (Item) -> Void) {
+    self.item = item
+    self.onOpen = onOpen
+    self.onCopy = onCopy
+    self.titleLines = RowView.lines(for: item.title, width: width - 14 - 48)
+    let textHeight = CGFloat(titleLines) * RowView.lineHeight
+    super.init(frame: NSRect(x: 0, y: 0, width: width, height: textHeight + (item.subtitle.isEmpty ? 13 : 29)))
+    setAccessibilityRole(.button)
+    setAccessibilityLabel("\(item.title). \(item.subtitle). Return opens it; the button on the right copies the question.")
+  }
+  required init?(coder: NSCoder) { return nil }
+
+  private var copyRect: NSRect { NSRect(x: bounds.maxX - 42, y: bounds.midY - 12, width: 28, height: 24) }
+
+
+  override func updateTrackingAreas() {
+    super.updateTrackingAreas()
+    for a in trackingAreas { removeTrackingArea(a) }
+    addTrackingArea(NSTrackingArea(rect: bounds, options: [.mouseEnteredAndExited, .activeAlways], owner: self, userInfo: ["zone": "row"]))
+    addTrackingArea(NSTrackingArea(rect: copyRect, options: [.mouseEnteredAndExited, .activeAlways], owner: self, userInfo: ["zone": "copy"]))
+  }
+  private func zone(_ e: NSEvent) -> String { (e.trackingArea?.userInfo?["zone"] as? String) ?? "row" }
+  override func mouseEntered(with e: NSEvent) {
+    if zone(e) == "copy" { overCopy = true } else { hovering = true }
+    needsDisplay = true
+  }
+  override func mouseExited(with e: NSEvent) {
+    if zone(e) == "copy" { overCopy = false } else { hovering = false; overCopy = false }
+    needsDisplay = true
+  }
+  override func mouseUp(with e: NSEvent) {
+    if copyRect.contains(convert(e.locationInWindow, from: nil)) {
+      onCopy(item)
+      copied = true
+      needsDisplay = true
+      DispatchQueue.main.asyncAfter(deadline: .now() + 1.4) { [weak self] in self?.copied = false; self?.needsDisplay = true }
+      return
+    }
+    enclosingMenuItem?.menu?.cancelTracking()
+    onOpen(item)
+  }
+
+  override func draw(_ dirtyRect: NSRect) {
+    let selected = hovering
+    if selected {
+      NSColor.selectedContentBackgroundColor.setFill()
+      NSBezierPath(roundedRect: bounds.insetBy(dx: 5, dy: 1), xRadius: 5, yRadius: 5).fill()
+    }
+    let fg: NSColor = selected ? .selectedMenuItemTextColor : .labelColor
+    let dim: NSColor = selected ? NSColor.selectedMenuItemTextColor.withAlphaComponent(0.7) : .secondaryLabelColor
+    let para = NSMutableParagraphStyle()
+    para.lineBreakMode = .byWordWrapping           // break between words, not inside one
+    para.lineSpacing = 0
+    let flat = NSMutableParagraphStyle()
+    flat.lineBreakMode = .byTruncatingTail
+    let textWidth = bounds.width - 14 - 48
+    let hasSub = !item.subtitle.isEmpty
+    let titleHeight = CGFloat(titleLines) * RowView.lineHeight
+    let titleY = bounds.maxY - 7 - titleHeight
+    let cell = NSTextFieldCell()                   // gives the last visible line its ellipsis
+    cell.attributedStringValue = NSAttributedString(string: item.title, attributes: [
+      .font: RowView.titleFont, .foregroundColor: fg, .paragraphStyle: para,
+    ])
+    cell.truncatesLastVisibleLine = true
+    cell.wraps = true
+    cell.drawInterior(withFrame: NSRect(x: 12, y: titleY, width: textWidth, height: titleHeight), in: self)
+    if hasSub {
+      NSAttributedString(string: item.subtitle, attributes: [
+        .font: NSFont.systemFont(ofSize: 11), .foregroundColor: dim, .paragraphStyle: flat,
+      ]).draw(in: NSRect(x: 14, y: bounds.minY + 6, width: textWidth, height: 14))
+    }
+
+    // the copy control
+    if overCopy || copied {
+      (selected ? NSColor.white.withAlphaComponent(0.22) : NSColor.labelColor.withAlphaComponent(0.10)).setFill()
+      NSBezierPath(roundedRect: copyRect, xRadius: 5, yRadius: 5).fill()
+    }
+    let glyphName = copied ? "checkmark" : "doc.on.doc"
+    let tint: NSColor = copied ? (selected ? .selectedMenuItemTextColor : .systemGreen) : (selected ? .selectedMenuItemTextColor : .secondaryLabelColor)
+    if let sym = NSImage(systemSymbolName: glyphName, accessibilityDescription: copied ? "Copied" : "Copy the question") {
+      let cfg = NSImage.SymbolConfiguration(pointSize: 12, weight: .medium)
+      let img = sym.withSymbolConfiguration(cfg) ?? sym
+      let size = img.size
+      let box = NSRect(x: copyRect.midX - size.width / 2, y: copyRect.midY - size.height / 2, width: size.width, height: size.height)
+      tint.set()
+      img.isTemplate = true
+      img.draw(in: box, from: .zero, operation: .sourceOver, fraction: 1.0)
+      NSColor.clear.set()
+    } else {
+      let p2 = NSMutableParagraphStyle(); p2.alignment = .center
+      NSAttributedString(string: copied ? "ok" : "copy", attributes: [
+        .font: NSFont.systemFont(ofSize: 10, weight: .medium), .foregroundColor: tint, .paragraphStyle: p2,
+      ]).draw(in: NSRect(x: copyRect.minX - 6, y: copyRect.midY - 6, width: copyRect.width + 12, height: 13))
+    }
+  }
+}
+
 final class AppDelegate: NSObject, NSApplicationDelegate, NSMenuDelegate {
   private var item: NSStatusItem!
   private var state = TrayState()
@@ -222,21 +418,26 @@ final class AppDelegate: NSObject, NSApplicationDelegate, NSMenuDelegate {
         : "Connection unavailable · \(state.unavailableSpaces.joined(separator: ", "))")
       menu.addItem(.separator())
       if !state.decisionsOk {
-        info("Some decisions could not be checked")
-        info("Refresh to try again. The count may be incomplete.")
+        info("Some of this could not be checked")
+        info("Refresh to try again — the list may be incomplete")
       }
-      if state.decisions.isEmpty {
-        if state.decisionsOk { info("No decisions need your input") }
+      let decisions = state.items.filter { $0.kind == "decision" }
+      let owed = state.items.filter { $0.kind == "owed" }
+      let waiting = state.items.filter { $0.kind == "waiting" }
+      if state.items.isEmpty {
+        if state.decisionsOk { info("Nothing open — nothing needs you, nothing owed either way") }
       } else {
-        let noun = state.decisions.count == 1 ? "decision needs" : "decisions need"
-        info("\(state.decisions.count) \(noun) your input")
-        for d in state.decisions.prefix(5) {
-          let decision = makeItem(d.body.count > 72 ? String(d.body.prefix(71)) + "…" : d.body, #selector(openDecision(_:)))
-          decision.toolTip = d.detail
-          decision.representedObject = [d.id, d.prompt]
-          menu.addItem(decision)
+        addRows(menu, decisions.count == 1 ? "1 decision needs you" : "\(decisions.count) decisions need you", decisions)
+        addRows(menu, owed.count == 1 ? "You owe 1 thing" : "You owe \(owed.count) things", owed)
+        // Grouped by person, because "waiting on praneet" is what someone
+        // actually wants to know before they chase it.
+        for who in orderedPeers(waiting) {
+          let theirs = waiting.filter { $0.who == who }
+          addRows(menu, theirs.count == 1 ? "Waiting on \(who)" : "Waiting on \(who) · \(theirs.count)", theirs)
+        }
+        if !decisions.isEmpty {
+          menu.addItem(makeItem(decisions.count > 1 ? "Review all \(decisions.count) in \(state.surfaceName)" : "Review it in \(state.surfaceName)", #selector(openAllDecisions)))
         }
-        menu.addItem(makeItem("\(state.decisions.count > 5 ? "Review all \(state.decisions.count) decisions" : "Review decisions") in \(state.surfaceName)", #selector(openAllDecisions)))
       }
       menu.addItem(.separator())
       info(state.workerRunning ? "Unattended work is on" : state.workerInstalled ? "Unattended work is paused" : "Unattended work is not set up")
@@ -274,6 +475,399 @@ final class AppDelegate: NSObject, NSApplicationDelegate, NSMenuDelegate {
     menu.addItem(makeItem("Quit pantheon menu bar", #selector(quit)))
   }
 
+
+  // MARK: the detail panel — the centred window a row opens
+
+  private var detailPanel: NSPanel?
+  private var panelItem: Item?
+  private var panelStatus: NSTextField?
+  private var panelText: NSTextView?
+  private var panelBodyHeight: NSLayoutConstraint?
+  private var panelHeadline: NSTextField?
+  private var panelRendered: NSAttributedString?     // the act laid out for a person
+  private var panelRaw: String = ""                  // the act exactly as it was sent
+  private var panelShowingRaw = false
+  private var panelRawToggle: NSButton?
+
+  private func label(_ text: String, size: CGFloat, weight: NSFont.Weight, color: NSColor, width: CGFloat) -> NSTextField {
+    let l = NSTextField(labelWithString: text)
+    l.font = .systemFont(ofSize: size, weight: weight)
+    l.textColor = color
+    l.lineBreakMode = .byWordWrapping
+    l.maximumNumberOfLines = 0
+    l.preferredMaxLayoutWidth = width
+    l.translatesAutoresizingMaskIntoConstraints = false
+    return l
+  }
+
+  /// How tall the body should be for this much text, between a compact minimum
+  /// and a cap that keeps the panel on screen.
+  private func bodyHeight(_ text: NSAttributedString, width: CGFloat) -> CGFloat {
+    let measured = text.boundingRect(with: NSSize(width: width - 4, height: .greatestFiniteMagnitude),
+                                     options: [.usesLineFragmentOrigin, .usesFontLeading]).height
+    return min(max(ceil(measured) + 22, 96), 400)
+  }
+
+  private func plain(_ text: String) -> NSAttributedString {
+    let para = NSMutableParagraphStyle()
+    para.paragraphSpacing = 10
+    para.lineSpacing = 1.5
+    return NSAttributedString(string: text, attributes: [
+      .font: NSFont.systemFont(ofSize: 13), .foregroundColor: NSColor.labelColor, .paragraphStyle: para,
+    ])
+  }
+
+  /**
+   * The act as blocks: paragraphs, the options as bullets, shell commands in a
+   * monospace run. The parsing is the CLI's (`pantheon tray-detail`), because it
+   * is testable there and this file stays a renderer.
+   */
+  private func render(_ blocks: [[String: Any]]) -> NSAttributedString {
+    let out = NSMutableAttributedString()
+    let body = NSMutableParagraphStyle()
+    body.paragraphSpacing = 12
+    body.lineSpacing = 1.5
+    let bullet = NSMutableParagraphStyle()
+    bullet.paragraphSpacing = 5
+    bullet.lineSpacing = 1.5
+    bullet.headIndent = 20
+    bullet.firstLineHeadIndent = 6
+    let code = NSMutableParagraphStyle()
+    code.paragraphSpacing = 2
+    code.headIndent = 20
+    code.firstLineHeadIndent = 12
+
+    for block in blocks {
+      let kind = block["kind"] as? String ?? "para"
+      if kind == "para", let text = block["text"] as? String {
+        out.append(NSAttributedString(string: text + "\n", attributes: [
+          .font: NSFont.systemFont(ofSize: 13), .foregroundColor: NSColor.labelColor, .paragraphStyle: body,
+        ]))
+      } else if kind == "bullets", let items = block["items"] as? [String] {
+        for item in items {
+          out.append(NSAttributedString(string: "•  " + item + "\n", attributes: [
+            .font: NSFont.systemFont(ofSize: 13), .foregroundColor: NSColor.labelColor, .paragraphStyle: bullet,
+          ]))
+        }
+        out.append(NSAttributedString(string: "\n", attributes: [.font: NSFont.systemFont(ofSize: 5)]))
+      } else if kind == "code", let lines = block["lines"] as? [String] {
+        for line in lines {
+          out.append(NSAttributedString(string: line + "\n", attributes: [
+            .font: NSFont.monospacedSystemFont(ofSize: 12, weight: .regular),
+            .foregroundColor: NSColor.labelColor,
+            .backgroundColor: NSColor.labelColor.withAlphaComponent(0.06),
+            .paragraphStyle: code,
+          ]))
+        }
+        out.append(NSAttributedString(string: "\n", attributes: [.font: NSFont.systemFont(ofSize: 5)]))
+      }
+    }
+    return out
+  }
+
+  private func showBody(_ text: NSAttributedString, width: CGFloat) {
+    guard let tv = panelText else { return }
+    tv.textStorage?.setAttributedString(text)
+    panelBodyHeight?.constant = bodyHeight(text, width: width)
+    if let p = detailPanel {
+      p.contentView?.layoutSubtreeIfNeeded()
+      let h = min(max((p.contentView?.fittingSize.height ?? 420) + 30, 300), 680)
+      let f = p.frame
+      p.setFrame(NSRect(x: f.minX, y: f.maxY - h, width: f.width, height: h), display: true, animate: false)
+    }
+  }
+
+  /**
+   * The relay's obligation body is ONE clipped line — enough for a menu row, not
+   * for a panel that says "here is the whole thing". So fetch the act behind it
+   * and lay it out. On demand, only while a panel is open.
+   */
+  private func loadDetail(_ item: Item, width: CGFloat) {
+    guard !item.ref.isEmpty else { return }
+    DispatchQueue.global().async {
+      let r = run(pantheonBin, ["tray-detail", item.ref], timeout: 20)
+      guard let out = r?.out, r?.code == 0,
+            let data = out.data(using: .utf8),
+            let j = try? JSONSerialization.jsonObject(with: data) as? [String: Any],
+            j["ok"] as? Bool == true else { return }
+      let blocks = j["blocks"] as? [[String: Any]] ?? []
+      let rendered = self.render(blocks)
+      let raw = j["raw"] as? String ?? ""
+      let headline = j["headline"] as? String ?? ""
+      DispatchQueue.main.async {
+        guard self.panelItem?.id == item.id else { return }
+        self.panelRendered = rendered
+        self.panelRaw = raw
+        self.panelRawToggle?.isHidden = raw.isEmpty
+        if !headline.isEmpty { self.panelHeadline?.stringValue = headline }
+        if !self.panelShowingRaw && rendered.length > 0 { self.showBody(rendered, width: width) }
+      }
+    }
+  }
+
+  /// Reformatting someone else's words is only honest if the original is one click away.
+  @objc private func panelToggleRaw() {
+    guard let item = panelItem else { return }
+    panelShowingRaw.toggle()
+    panelRawToggle?.title = panelShowingRaw ? "Show it laid out" : "Show it as sent"
+    let width: CGFloat = 620 - 52
+    if panelShowingRaw { showBody(plain(panelRaw.isEmpty ? item.detail : panelRaw), width: width) }
+    else if let r = panelRendered { showBody(r, width: width) }
+  }
+
+  /**
+   * Everything about one open thing, in the middle of the screen: who it is
+   * from, the whole text (a menu row can only ever show a clipped line), and the
+   * actions that settle it. The menu answers "is anything waiting"; this answers
+   * "what is it, and what do I do about it" without a terminal.
+   */
+  func showDetail(_ item: Item) {
+    detailPanel?.close()
+    panelItem = item
+    let width: CGFloat = 620
+    let inner = width - 52
+    let panel = NSPanel(contentRect: NSRect(x: 0, y: 0, width: width, height: 470),
+                        styleMask: [.titled, .closable, .fullSizeContentView], backing: .buffered, defer: false)
+    panel.title = "Pantheon"
+    panel.titlebarAppearsTransparent = true
+    panel.isMovableByWindowBackground = true
+    panel.level = .floating
+    panel.isReleasedWhenClosed = false
+    panel.hidesOnDeactivate = false
+
+    let effect = NSVisualEffectView(frame: NSRect(x: 0, y: 0, width: width, height: 470))
+    effect.material = .popover
+    effect.blendingMode = .behindWindow
+    effect.state = .active
+    effect.autoresizingMask = [.width, .height]
+
+    let stack = NSStackView()
+    stack.orientation = .vertical
+    stack.alignment = .leading
+    stack.spacing = 9
+    stack.translatesAutoresizingMaskIntoConstraints = false
+    effect.addSubview(stack)
+
+    var eyebrow = item.heading.uppercased()
+    if item.when > 0 { eyebrow += "  ·  " + Item.age(item.when) }
+    if !item.space.isEmpty { eyebrow += "  ·  " + item.space }
+    let eye = label(eyebrow, size: 11, weight: .semibold, color: .secondaryLabelColor, width: inner)
+    stack.addArrangedSubview(eye)
+    let headline = label(item.headline, size: 17, weight: .semibold, color: .labelColor, width: inner)
+    panelHeadline = headline
+    stack.addArrangedSubview(headline)
+
+    // the whole text, selectable and scrollable — a decision is often several paragraphs
+    let scroll = NSScrollView()
+    scroll.hasVerticalScroller = true
+    scroll.drawsBackground = false
+    scroll.borderType = .noBorder
+    scroll.translatesAutoresizingMaskIntoConstraints = false
+    let tv = NSTextView()
+    tv.isEditable = false
+    tv.isSelectable = true
+    tv.drawsBackground = false
+    tv.font = .systemFont(ofSize: 13)
+    tv.textColor = .labelColor
+    tv.textStorage?.setAttributedString(plain(item.detail))
+    tv.textContainerInset = NSSize(width: 0, height: 6)
+    tv.isVerticallyResizable = true
+    tv.isHorizontallyResizable = false
+    tv.autoresizingMask = [.width]
+    tv.textContainer?.widthTracksTextView = true
+    scroll.documentView = tv
+    panelText = tv
+    stack.addArrangedSubview(scroll)
+    stack.setCustomSpacing(14, after: stack.arrangedSubviews[1])
+
+    var meta = item.isDecision ? "decision \(item.id)" : "obligation \(item.id)"
+    if !item.goal.isEmpty { meta += "  ·  goal \(item.goal)" }
+    stack.addArrangedSubview(label(meta, size: 11, weight: .regular, color: .tertiaryLabelColor, width: inner))
+
+    let status = label("", size: 11, weight: .medium, color: .secondaryLabelColor, width: inner)
+    status.isHidden = true
+    panelStatus = status
+    stack.addArrangedSubview(status)
+
+    let row = NSStackView()
+    row.orientation = .horizontal
+    row.spacing = 10
+    row.translatesAutoresizingMaskIntoConstraints = false
+    let open = NSButton(title: "Open in \(state.surfaceName)", target: self, action: #selector(panelOpen))
+    open.bezelStyle = .rounded
+    open.keyEquivalent = "\r"
+    row.addArrangedSubview(open)
+    let copy = NSButton(title: "Copy the question", target: self, action: #selector(panelCopy))
+    copy.bezelStyle = .rounded
+    row.addArrangedSubview(copy)
+    if item.isDecision {
+      let done = NSButton(title: "Mark done", target: self, action: #selector(panelDone))
+      done.bezelStyle = .rounded
+      done.toolTip = "Answer it as handled, so it stops asking"
+      row.addArrangedSubview(done)
+    }
+    let thread = NSButton(title: "Show the thread", target: self, action: #selector(panelThread))
+    thread.bezelStyle = .rounded
+    row.addArrangedSubview(thread)
+    let rawToggle = NSButton(title: "Show it as sent", target: self, action: #selector(panelToggleRaw))
+    rawToggle.bezelStyle = .rounded
+    rawToggle.toolTip = "The act exactly as your teammate's agent wrote it"
+    rawToggle.isHidden = true
+    panelRawToggle = rawToggle
+    row.addArrangedSubview(rawToggle)
+    let close = NSButton(title: "Close", target: self, action: #selector(panelClose))
+    close.bezelStyle = .rounded
+    close.keyEquivalent = "\u{1b}"
+    row.addArrangedSubview(close)
+    stack.addArrangedSubview(row)
+
+    NSLayoutConstraint.activate([
+      stack.leadingAnchor.constraint(equalTo: effect.leadingAnchor, constant: 26),
+      stack.trailingAnchor.constraint(equalTo: effect.trailingAnchor, constant: -26),
+      stack.topAnchor.constraint(equalTo: effect.topAnchor, constant: 36),
+      stack.bottomAnchor.constraint(equalTo: effect.bottomAnchor, constant: -22),
+      scroll.widthAnchor.constraint(equalTo: stack.widthAnchor),
+      row.widthAnchor.constraint(lessThanOrEqualTo: stack.widthAnchor),
+    ])
+    let bh = scroll.heightAnchor.constraint(equalToConstant: bodyHeight(plain(item.detail), width: inner))
+    bh.isActive = true
+    panelBodyHeight = bh
+
+    panel.contentView = effect
+    // Sized to what it holds: a one-line question should not open a half-empty window.
+    effect.layoutSubtreeIfNeeded()
+    let height = min(max(effect.fittingSize.height + 30, 300), 660)
+    panel.setContentSize(NSSize(width: width, height: height))
+    panel.center()
+    detailPanel = panel
+    NSApp.activate(ignoringOtherApps: true)
+    panel.makeKeyAndOrderFront(nil)
+    panelRendered = nil
+    panelRaw = ""
+    panelShowingRaw = false
+    loadDetail(item, width: inner)
+  }
+
+  private func setStatus(_ text: String) {
+    panelStatus?.stringValue = text
+    panelStatus?.isHidden = text.isEmpty
+  }
+
+  @objc private func panelClose() {
+    detailPanel?.close()
+    detailPanel = nil
+    panelText = nil
+    panelBodyHeight = nil
+    panelItem = nil
+    panelHeadline = nil
+    panelRendered = nil
+    panelRawToggle = nil
+    panelRaw = ""
+    panelShowingRaw = false
+  }
+  @objc private func panelCopy() {
+    guard let item = panelItem else { return }
+    copyPrompt(item)
+    setStatus("Copied. Paste it into your agent.")
+  }
+  @objc private func panelOpen() {
+    guard let item = panelItem else { return }
+    panelClose()
+    openItem(item)
+  }
+  @objc private func panelThread() {
+    guard let item = panelItem else { return }
+    panelClose()
+    showThread(item)
+  }
+  /// Answer the decision as handled, with no terminal — the same action the alert's Done takes.
+  @objc private func panelDone() {
+    guard let item = panelItem, item.isDecision else { return }
+    setStatus("Marking it done…")
+    var payload: [String: Any] = ["action": "done", "decision": item.id]
+    if !item.ref.isEmpty { payload["act"] = item.ref }
+    guard writeAction(payload) else {
+      setStatus("Could not write the action. Use Show the thread instead.")
+      return
+    }
+    DispatchQueue.global().async {
+      let r = run(pantheonBin, ["explain", "--queued"], timeout: 25)
+      DispatchQueue.main.async {
+        self.setStatus(r?.code == 0
+          ? "Done — it is no longer waiting on you."
+          : "Could not mark it done. Use Show the thread instead.")
+        self.refresh()
+      }
+    }
+  }
+
+  // MARK: item actions, shared by the menu rows and the panel
+
+  private func binDir() -> String {
+    (Bundle.main.executablePath as NSString?)?.deletingLastPathComponent
+      ?? URL(fileURLWithPath: CommandLine.arguments[0]).deletingLastPathComponent().path
+  }
+  /// What `pantheon explain --queued` reads. Same file the desktop alert writes.
+  private func writeAction(_ payload: [String: Any]) -> Bool {
+    guard let data = try? JSONSerialization.data(withJSONObject: payload) else { return false }
+    return (try? data.write(to: URL(fileURLWithPath: binDir() + "/.hud-action.json"), options: .atomic)) != nil
+  }
+  func copyPrompt(_ item: Item) {
+    let pb = NSPasteboard.general
+    pb.clearContents()
+    pb.setString(item.prompt, forType: .string)
+  }
+  /// Open the agent with this item's question already written out.
+  func openItem(_ item: Item) {
+    copyPrompt(item)
+    if writeAction(["action": "open", "prompt": item.prompt]) {
+      openCommand("pantheon-explain.command")
+    } else {
+      reportFailure("Could not open your agent. The question is copied; paste it into your agent.")
+    }
+  }
+  /// The act behind it, in Terminal, with the reply menu.
+  func showThread(_ item: Item) {
+    var payload: [String: Any] = ["action": "details"]
+    if !item.ref.isEmpty { payload["act"] = item.ref }
+    if item.isDecision { payload["decision"] = item.id }
+    if writeAction(payload) { openCommand("pantheon-details.command") }
+    else { reportFailure("Could not open Terminal. Run pantheon doctor to check your setup.") }
+  }
+
+  /// Peers in the order their oldest unanswered thing arrived — longest wait first.
+  private func orderedPeers(_ items: [Item]) -> [String] {
+    var seen: [String] = []
+    for i in items.sorted(by: { $0.when < $1.when }) where !seen.contains(i.who) { seen.append(i.who) }
+    return seen
+  }
+
+  /// A titled group of rows. Six at most: a menu is for triage, and anything
+  /// deeper belongs in `pantheon brief`, which the last row opens.
+  private func addRows(_ menu: NSMenu, _ title: String, _ items: [Item]) {
+    guard !items.isEmpty else { return }
+    let header = NSMenuItem(title: title, action: nil, keyEquivalent: "")
+    header.isEnabled = false
+    header.attributedTitle = NSAttributedString(string: title, attributes: [
+      .font: NSFont.systemFont(ofSize: 11, weight: .semibold),
+      .foregroundColor: NSColor.secondaryLabelColor,
+    ])
+    menu.addItem(header)
+    for item in items.prefix(6) {
+      let mi = NSMenuItem(title: item.title, action: nil, keyEquivalent: "")
+      mi.toolTip = item.detail
+      mi.view = RowView(item: item, width: 430,
+                        onOpen: { [weak self] it in self?.showDetail(it) },
+                        onCopy: { [weak self] it in self?.copyPrompt(it) })
+      menu.addItem(mi)
+    }
+    if items.count > 6 {
+      let more = NSMenuItem(title: "…and \(items.count - 6) more", action: nil, keyEquivalent: "")
+      more.isEnabled = false
+      menu.addItem(more)
+    }
+  }
+
   private func makeItem(_ title: String, _ sel: Selector) -> NSMenuItem {
     let mi = NSMenuItem(title: title, action: sel, keyEquivalent: "")
     mi.target = self
@@ -307,10 +901,6 @@ final class AppDelegate: NSObject, NSApplicationDelegate, NSMenuDelegate {
   @objc private func openStatus() { openCommand("pantheon-status.command") }
   @objc private func openDoctor() { openCommand("pantheon-doctor.command") }
   @objc private func openApprovals() { openCommand("pantheon-approvals.command") }
-  @objc private func openDecision(_ sender: NSMenuItem) {
-    let pair = sender.representedObject as? [String] ?? []
-    openAgent(id: pair.first ?? "all", prompt: pair.count > 1 ? pair[1] : "")
-  }
   @objc private func openAllDecisions() { openAgent(id: "all", prompt: state.decisionsPrompt) }
   /**
    * The handoff: queue the chosen decision id for `pantheon explain --queued`,