opencode-context-tree 0.1.1 → 0.2.1

package/src/core/tree.ts

@@ -40,6 +40,9 @@ export type TurnRow = {
   isTip: boolean
   isDecision: boolean
   isSummary: boolean
+  /** false for rows the current session never sends: an ancestor's rows past the point where
+   *  this path forked away, and every other branch's rows (DESIGN.md §7.1). */
+  inContext: boolean
 }
 
 export type StepRow = {
@@ -55,11 +58,16 @@ export type StepRow = {
   tokens: number
   estimated: boolean
   durationMs?: number
+  /** Time the model spent reasoning for the owning message, folded onto its first real step:
+   *  outside the `all` filter thinking parts get no row of their own. */
+  thinkingMs?: number
   isError: boolean
   isCropped: boolean
   warn: boolean
   /** Label of the owning message, shown on its first step row only. */
   label?: string
+  /** See TurnRow.inContext. */
+  inContext: boolean
 }
 
 export type BranchRow = {
@@ -82,7 +90,19 @@ export type BranchRow = {
   last: boolean
 }
 
-export type Row = TurnRow | StepRow | BranchRow
+/** Decoration drawn in an ancestor right after the point where the current path forked away:
+ *  everything below it in that session is history the model is not shown. Never selectable. */
+export type SeparatorRow = {
+  kind: "separator"
+  id: string
+  depth: number
+  gutter: string
+  text: string
+}
+
+export type Row = TurnRow | StepRow | BranchRow | SeparatorRow
+
+const OFF_PATH_TEXT = "── not in this branch's context ──"
 
 export type TreeView = {
   rows: Row[]
@@ -293,7 +313,7 @@ function isCropped(ctx: Ctx, messageID: string, partID: string): boolean {
   return ctx.crops.some((c) => c.messageID === messageID && (c.partID === undefined || c.partID === partID))
 }
 
-function emitAssistantRows(ctx: Ctx, sessionID: string, message: TranscriptMessage, depth: number, gutter: string, out: Row[]): void {
+function emitAssistantRows(ctx: Ctx, sessionID: string, message: TranscriptMessage, depth: number, gutter: string, inContext: boolean, out: Row[]): void {
   if (message.summary) {
     // OpenCode-native compaction summary: one row for the whole message (DESIGN.md §7).
     if (!stepAllowed(ctx.filter, "text")) return
@@ -319,18 +339,29 @@ function emitAssistantRows(ctx: Ctx, sessionID: string, message: TranscriptMessa
       isError: false,
       isCropped: false,
       warn: tokens >= WARN_TOKENS,
+      inContext,
     })
     return
   }
 
+  // Reasoning parts were 40–50% of the outline and say nothing: outside `all` they get no row
+  // and their duration rides the message's first real step instead (`· 9.8s thought`).
+  const collapseThinking = ctx.filter !== "all"
+  const rows: StepRow[] = []
+  let thinkingMs: number | undefined
   let first = true
   for (const part of message.parts) {
     const kind = stepKind(part)
+    if (collapseThinking && kind === "reasoning") {
+      const ms = durationOfPart(part)
+      if (ms !== undefined) thinkingMs = (thinkingMs ?? 0) + ms
+      continue
+    }
     const label = first ? ctx.labels[message.id] : undefined
     if (!stepAllowed(ctx.filter, kind, Boolean(label))) continue
     const { tokens, estimated } = stepTokensFor(part, message)
     first = false
-    out.push({
+    rows.push({
       kind: "step",
       id: `${sessionID}:${message.id}:${part.id}`,
       sessionID,
@@ -347,8 +378,40 @@ function emitAssistantRows(ctx: Ctx, sessionID: string, message: TranscriptMessa
       isCropped: isCropped(ctx, message.id, part.id),
       warn: tokens >= WARN_TOKENS,
       label,
+      inContext,
     })
   }
+
+  if (rows.length > 0) {
+    if (thinkingMs !== undefined) rows[0]!.thinkingMs = thinkingMs
+  } else if (collapseThinking) {
+    // nothing but thinking: keep one row, standing for the whole message, or it goes invisible
+    const thinking = message.parts.filter((p) => stepKind(p) === "reasoning")
+    const label = ctx.labels[message.id]
+    if (thinking.length > 0 && stepAllowed(ctx.filter, "reasoning", Boolean(label))) {
+      const tokens = thinking.reduce((sum, p) => sum + stepTokensFor(p, message).tokens, 0)
+      rows.push({
+        kind: "step",
+        id: `${sessionID}:${message.id}:${thinking[0]!.id}`,
+        sessionID,
+        messageID: message.id,
+        partID: thinking[0]!.id,
+        depth,
+        gutter,
+        glyph: "○",
+        preview: partPreview(thinking[0]!),
+        tokens,
+        estimated: thinking.some((p) => stepTokensFor(p, message).estimated),
+        durationMs: thinkingMs,
+        isError: false,
+        isCropped: isCropped(ctx, message.id, thinking[0]!.id),
+        warn: tokens >= WARN_TOKENS,
+        label,
+        inContext,
+      })
+    }
+  }
+  out.push(...rows)
 }
 
 /** A branch is open in the outline when the user has toggled it: on-path branches start open
@@ -441,17 +504,34 @@ function emitChildBranches(ctx: Ctx, sessionID: string, anchorMessageID: string,
   })
 }
 
+/** The message after which the current path leaves `sessionID` — its on-path child's anchor.
+ *  undefined for the current session and for branches off the path (nothing forks away). */
+function forkAnchorOf(ctx: Ctx, sessionID: string): string | undefined {
+  const childID = ctx.onPathChild.get(sessionID)
+  return childID ? ctx.state.sessions[childID]?.anchorMessageID : undefined
+}
+
 /**
  * Depth-first over one session: emit its own `messages` (the tail after any copied prefix)
  * as rows at `depth`/`gutter`, and after each message recurse into the branches anchored on
  * it. `turnStart` seeds the turn counter (a branch continues its parent's numbering).
+ *
+ * Rows are marked `inContext` while they are part of what the current session sends: an
+ * ancestor's rows up to and including its fork point, and the current session's own rows.
+ * Where that stops, one separator row is drawn before the next row this session contributes.
  */
 function walkSession(ctx: Ctx, sessionID: string, messages: TranscriptMessage[], depth: number, gutter: string, turnStart: number, out: Row[]): void {
   const lastUserIndex = findLastUserIndex(messages, ctx.filter)
   const counter = { turn: turnStart }
   // set by a hidden plugin command turn, so the acknowledgement that follows it goes too
   let inPluginCommand = false
+  const forkAnchor = forkAnchorOf(ctx, sessionID)
+  let inContext = ctx.onPath.has(sessionID)
+  // anchor "" — the path forked before this session's first message, so none of it is sent
+  let separatorDue = inContext && forkAnchor === ""
+  if (separatorDue) inContext = false
   messages.forEach((message, i) => {
+    const before = out.length
     if (message.role === "user") {
       inPluginCommand = hiddenPluginTurn(ctx.filter, message)
       if (!inPluginCommand) {
@@ -478,15 +558,26 @@ function walkSession(ctx: Ctx, sessionID: string, messages: TranscriptMessage[],
             isTip: i === lastUserIndex,
             isDecision,
             isSummary,
+            inContext,
           })
         }
       }
     } else if (!inPluginCommand) {
-      emitAssistantRows(ctx, sessionID, message, depth, gutter, out)
+      emitAssistantRows(ctx, sessionID, message, depth, gutter, inContext, out)
     }
     // Branches attach right after their anchor — the last message they share with
     // this session — whichever role that message has.
     emitChildBranches(ctx, sessionID, message.id, depth, gutter, out)
+
+    // drawn lazily, so a fork point with nothing after it never leaves a dangling separator
+    if (separatorDue && out.length > before) {
+      out.splice(before, 0, { kind: "separator", id: `separator:${sessionID}`, depth, gutter, text: OFF_PATH_TEXT })
+      separatorDue = false
+    }
+    if (inContext && message.id === forkAnchor) {
+      inContext = false
+      separatorDue = true
+    }
   })
 }
 
@@ -502,6 +593,8 @@ function rowSearchFields(row: Row): string[] {
       return row.label ? [row.preview, row.label] : [row.preview]
     case "branch":
       return row.model ? [row.name, row.model, row.status] : [row.name, row.status]
+    case "separator":
+      return [] // decoration: a flat search hit list has no fork point to divide
   }
 }
 
@@ -644,7 +737,7 @@ export function buildTreeView(o: BuildOptions): TreeView {
   let currentRowId: string | undefined
   for (let i = rows.length - 1; i >= 0; i--) {
     const r = rows[i]!
-    if (r.kind !== "branch" && r.sessionID === o.currentSessionID) {
+    if ((r.kind === "turn" || r.kind === "step") && r.sessionID === o.currentSessionID) {
       currentRowId = r.id
       break
     }

package/src/server/index.ts

@@ -16,6 +16,7 @@ import { CTREE_HELP, parseCtreeArgs } from "../core/ctree-args.js"
 import { autoMark, planResultCrop, resultCandidates, topCandidate, type CropRules, DEFAULT_RULES } from "../core/cropplan.js"
 import { planUndo } from "../core/undo.js"
 import { exportDecisions } from "../core/decision.js"
+import { PLUGIN_VERSION } from "../shared/version.js"
 import type { Transcript, TranscriptMessage } from "../core/transcript.js"
 import { parseForkTitle } from "../core/adopt.js"
 import { adoptNativeForks } from "../shared/adopt.js"
@@ -97,7 +98,7 @@ export const server: Plugin = async ({ worktree, client, directory }, options) =
         const cmd = parseCtreeArgs(input.arguments)
         switch (cmd.kind) {
           case "help":
-            return say(output, `${cmd.error ? `error: ${cmd.error}\n\n` : ""}${CTREE_HELP}`)
+            return say(output, `${cmd.error ? `error: ${cmd.error}\n\n` : ""}${CTREE_HELP}\n(opencode-context-tree ${PLUGIN_VERSION})`)
           case "status": {
             await adopt() // headless clients have no TUI half to do it for them
             const state = store.stateForSession(sessionID)
@@ -108,7 +109,7 @@ export const server: Plugin = async ({ worktree, client, directory }, options) =
             const branches = Object.values(state.sessions).filter((b) => b.parentSessionID === sessionID)
             // an adopted native fork carries no journal name: fall back to the session's own title
             const title = me && !me.name ? ((await client.session.get({ path: { id: sessionID }, query: { directory } }).catch(() => undefined))?.data as { title?: string } | undefined)?.title : undefined
-            return say(output, [`tree ${state.treeId}`, me ? `this session is ⎇ ${me.name ?? title ?? "branch"} (${me.status}) of ${me.parentSessionID}${me.note ? ` — ${me.note}` : ""}` : "this session is the trunk", `${branches.length} branch(es) from here: ${branches.map((b) => `${b.name ?? b.sessionID} [${b.status}]`).join(", ") || "none"}`, `${crops.length} active crop(s), ~${hidden} tokens hidden`, `${Object.values(state.decisions).filter((d) => d.sessionID === sessionID && !d.hidden).length} decision record(s) here`].join("\n"))
+            return say(output, [`opencode-context-tree ${PLUGIN_VERSION} · tree ${state.treeId}`, me ? `this session is ⎇ ${me.name ?? title ?? "branch"} (${me.status}) of ${me.parentSessionID}${me.note ? ` — ${me.note}` : ""}` : "this session is the trunk", `${branches.length} branch(es) from here: ${branches.map((b) => `${b.name ?? b.sessionID} [${b.status}]`).join(", ") || "none"}`, `${crops.length} active crop(s), ~${hidden} tokens hidden`, `${Object.values(state.decisions).filter((d) => d.sessionID === sessionID && !d.hidden).length} decision record(s) here`].join("\n"))
           }
           case "branch": {
             const tr = await transcriptOf(sessionID)

package/src/shared/version.ts

@@ -0,0 +1,3 @@
+/** Stamped by scripts/build.ts from package.json (the release tag); "dev" when run from source. */
+declare const __CTREE_VERSION__: string | undefined
+export const PLUGIN_VERSION: string = typeof __CTREE_VERSION__ === "string" ? __CTREE_VERSION__ : "dev"

package/src/tui/actions.ts

@@ -5,9 +5,13 @@
  */
 import type { TuiPluginApi } from "@opencode-ai/plugin/tui"
 import { createSignal } from "solid-js"
+import fs from "node:fs"
+import path from "node:path"
 import type { JournalStore } from "../shared/store.js"
 import type { CropAppliedData, JournalEntry } from "../core/journal.js"
 import type { UndoPlan } from "../core/undo.js"
+import type { TranscriptMessage } from "../core/transcript.js"
+import { contextSizeOf, formatK, type MinimalMessage } from "../core/tokens.js"
 import { DECISION_SYSTEM, branchTranscriptText, buildDecisionDraftPrompt, decisionMessageText, decisionTemplate, openSiblings } from "../core/decision.js"
 import { editInExternalEditor, hasEditor } from "./editor.js"
 import { debug } from "../shared/debug.js"
@@ -325,22 +329,55 @@ export type MergeMode = "squash" | "squash-no-llm" | "discard" | "tournament"
 /** The promise every merge confirmation repeats — the reason a merge is safe to try. */
 export const MERGE_TRUST = "Your transcript is never rewritten; the record is appended to the trunk as a normal message."
 
+/** The tree route's undo key (`x` stays as an alias); every hint we print names this one. */
+export const UNDO_KEY = "u"
+
 /** What the $EDITOR gate opens with: the draft is a proposal, saving is the confirmation. */
 export const MERGE_GATE_NOTICE = `Edit the ◆ decision record, then save to confirm (empty file or a non-zero exit aborts the merge).\n${MERGE_TRUST}`
 
-/** Shared copy for the merge picker (palette and route). */
-export function mergeDialogTitle(branchName: string, trunkTitle?: string): string {
-  return `Merge ⎇ ${branchName} → ${trunkTitle ? clip(trunkTitle, 28) : "the trunk"}`
+/** The discard gate's message: the same promise, plus the way back. */
+export const DISCARD_NOTICE = `${MERGE_TRUST}\nThe branch is only marked rejected — ${UNDO_KEY} (alias x) undoes it.`
+
+/** Where the merge lands, as the picker should name it. `label` is `TRUNK_LABEL` for the tree
+ *  root, else the parent branch's name; the figures come from the parent's own transcript. */
+export type MergeTarget = { label: string; turns: number; tokens: number }
+
+export const TRUNK_LABEL = "trunk"
+
+/** The picker's destination figures, computed the same way on every surface (the gauge's own
+ *  context size and the user-turn count) so the numbers on one screen agree. */
+export function mergeTargetOf(label: string, messages: readonly TranscriptMessage[]): MergeTarget {
+  const minimal = messages.map((m): MinimalMessage => ({ info: m.role === "assistant" ? { role: "assistant", tokens: m.tokens } : { role: "user" }, parts: m.parts }))
+  return { label, turns: messages.filter((m) => m.role === "user").length, tokens: contextSizeOf(minimal).tokens }
+}
+
+/** The branch's *own* user turns — the ones a squash folds into the record. Sliced like
+ *  `branchTranscriptText`: everything past the anchor's index in the parent (an unknown anchor
+ *  counts the whole session rather than throwing; this figure is only a label). */
+export function ownTurnCount(messages: readonly { role: string }[], anchor: { messageID?: string; parentMessageIDs: readonly string[] }): number {
+  const anchorIndex = anchor.messageID ? anchor.parentMessageIDs.indexOf(anchor.messageID) : -1
+  return messages.slice(anchorIndex + 1).filter((m) => m.role === "user").length
+}
+
+/** Shared copy for the merge picker (palette and route). Naming the destination "trunk" rather
+ *  than quoting the parent's title keeps the title from reading as a question ("→ What does git
+ *  rebase do?"). */
+export function mergeDialogTitle(branchName: string, target?: MergeTarget | string): string {
+  // a bare parent title is the old call shape, and quoting it is the bug: name the trunk instead
+  if (!target || typeof target === "string") return `Merge ⎇ ${branchName} → the trunk`
+  const where = target.label === TRUNK_LABEL ? TRUNK_LABEL : `⎇ ${clip(target.label, 24)}`
+  return `Merge ⎇ ${branchName} → ${where} (${plural(target.turns, "turn")}, ~${formatK(target.tokens)})`
 }
 
 /** Tournament only exists when there is something to compare against. Descriptions render on
  *  the option's own line, which truncates past ~50 columns — keep them short; the full promise
  *  is repeated at the confirmation step (`MERGE_TRUST`). */
-export function mergeDialogOptions(input: { siblings: number }): { title: string; value: MergeMode; description: string }[] {
+export function mergeDialogOptions(input: { siblings: number; turns?: number }): { title: string; value: MergeMode; description: string }[] {
+  const folds = input.turns === undefined ? "the branch" : plural(input.turns, "turn")
   return [
-    { title: "Squash", value: "squash" as const, description: "drafts a ◆ decision record you confirm" },
-    { title: "Squash without LLM", value: "squash-no-llm" as const, description: "you write the record yourself" },
-    { title: "Discard", value: "discard" as const, description: "rejected; nothing lands in the trunk" },
+    { title: "Squash", value: "squash" as const, description: `1 model call · folds ${folds} into one ◆ record` },
+    { title: "Squash without LLM", value: "squash-no-llm" as const, description: "you write it · no model call" },
+    { title: "Discard", value: "discard" as const, description: "rejected · nothing lands in the trunk" },
     ...(input.siblings > 0 ? [{ title: "Tournament", value: "tournament" as const, description: "compare sibling branches and keep one" }] : []),
   ]
 }
@@ -353,6 +390,50 @@ export type MergeInput = {
   confirm?: (draft: string) => Promise<string | undefined>
 }
 
+/** Dialogs opened from an action (not from a route/palette handler), so every caller of
+ *  `mergeBranch` gets the same gate. Both resolve to "cancelled" when the stack closes. */
+function confirmDialog(ctx: ActionContext, title: string, message: string): Promise<boolean> {
+  return new Promise((resolve) => {
+    ctx.api.ui.dialog.replace(
+      () =>
+        ctx.api.ui.DialogConfirm({
+          title,
+          message,
+          onConfirm: () => {
+            resolve(true)
+            ctx.api.ui.dialog.clear()
+          },
+          onCancel: () => {
+            resolve(false)
+            ctx.api.ui.dialog.clear()
+          },
+        }),
+      () => resolve(false),
+    )
+  })
+}
+
+function promptDialog(ctx: ActionContext, title: string, placeholder?: string): Promise<string | undefined> {
+  return new Promise((resolve) => {
+    ctx.api.ui.dialog.replace(
+      () =>
+        ctx.api.ui.DialogPrompt({
+          title,
+          placeholder,
+          onConfirm: (value) => {
+            resolve(value)
+            ctx.api.ui.dialog.clear()
+          },
+          onCancel: () => {
+            resolve(undefined)
+            ctx.api.ui.dialog.clear()
+          },
+        }),
+      () => resolve(undefined),
+    )
+  })
+}
+
 /** Close the branch the session lives on (DESIGN.md §6.4). Returns the parent session id. */
 export async function mergeBranch(ctx: ActionContext, input: MergeInput): Promise<string | undefined> {
   const treeId = ctx.store.ensureTree(input.sessionID, "tui")
@@ -364,8 +445,31 @@ export async function mergeBranch(ctx: ActionContext, input: MergeInput): Promis
   debug("merge.start", { mode: input.mode, sessionID: input.sessionID, parentID })
   await abortIfBusy(ctx, input.sessionID)
 
+  // both paths measure the branch by its own turns: what a squash folds into the record is
+  // also what a discard throws away — the prefix shared with the parent is neither
+  const parentMsgs = await ctx.api.client.session.messages({ sessionID: parentID, directory: ctx.directory }).catch(() => undefined)
+  const parentMessageIDs = ((parentMsgs?.data as any[]) ?? []).map((m) => String(m.info.id))
+  const own = await fetchOwnTranscript(ctx, input.sessionID)
+  const turns = ownTurnCount(own.messages, { messageID: branch.anchorMessageID, parentMessageIDs })
+
   if (input.mode === "discard") {
-    record(ctx, treeId, "branch.closed", { sessionID: input.sessionID, status: "rejected", note: input.note })
+    // discard is the one mode that lands nothing, so it gets its own gate — and a cancelled
+    // note prompt has to abort too, not fall through as "no note"
+    const ok = await confirmDialog(ctx, `Discard ⎇ ${name} (${plural(turns, "turn")})?`, DISCARD_NOTICE)
+    if (!ok) {
+      ctx.api.ui.toast({ variant: "warning", message: `⎇ ${name} kept — nothing discarded` })
+      return undefined
+    }
+    let note = input.note
+    if (note === undefined) {
+      const answer = await promptDialog(ctx, "Why? (optional note on the close marker)", "dead end")
+      if (answer === undefined) {
+        ctx.api.ui.toast({ variant: "warning", message: `⎇ ${name} kept — nothing discarded` })
+        return undefined
+      }
+      note = answer.trim() || undefined
+    }
+    record(ctx, treeId, "branch.closed", { sessionID: input.sessionID, status: "rejected", note })
     await mirrorMetadata(ctx, input.sessionID, { status: "rejected" })
     navigateToSession(ctx, parentID)
     ctx.api.ui.toast({ variant: "success", message: `⎇ ${name} discarded — back on the trunk` })
@@ -373,9 +477,6 @@ export async function mergeBranch(ctx: ActionContext, input: MergeInput): Promis
   }
 
   // --- draft ---------------------------------------------------------------
-  const parentMsgs = await ctx.api.client.session.messages({ sessionID: parentID, directory: ctx.directory })
-  const parentMessageIDs = ((parentMsgs.data as any[]) ?? []).map((m) => String(m.info.id))
-  const own = await fetchOwnTranscript(ctx, input.sessionID)
   const transcript = branchTranscriptText(own, { messageID: branch.anchorMessageID, parentMessageIDs })
   const model = branch.branchModel ?? branch.trunkModel
   const modelRef = model ? { providerID: model.split("/")[0]!, modelID: model.split("/").slice(1).join("/") } : undefined
@@ -441,7 +542,26 @@ async function fetchOwnTranscript(ctx: ActionContext, sessionID: string) {
 /** Shared copy for the branch-name dialog (palette and route). */
 export const BRANCH_DIALOG = { title: "Branch here → new OpenCode session", placeholder: "name, e.g. try-redis", modelTitle: "Model for this branch (Enter keeps the current one)" }
 
+/** Where `y` lands when the terminal has no OSC 52 clipboard (relative to the project). */
+export const COPY_HINT = ".opencode/context-tree/last-copy.txt"
+
+/** `y` copy: the terminal's own clipboard through @opentui's OSC 52 (works over ssh/tmux when
+ *  the terminal allows it), falling back to `COPY_HINT`. Throws if that file cannot be written. */
+export function copyText(api: TuiPluginApi, text: string, directory: string): { target: "clipboard" | "file"; hint: string } {
+  const renderer = api.renderer as unknown as { copyToClipboardOSC52?: (text: string) => boolean } | undefined
+  // an empty selection must never wipe the user's clipboard; it still lands in the file
+  if (text && renderer?.copyToClipboardOSC52?.(text)) return { target: "clipboard", hint: "clipboard" }
+  const file = path.join(directory, COPY_HINT)
+  fs.mkdirSync(path.dirname(file), { recursive: true })
+  fs.writeFileSync(file, text)
+  return { target: "file", hint: COPY_HINT }
+}
+
 /** Truncate to `max` columns with an ellipsis — the sidebar and dialogs are narrow. */
 export function clip(text: string, max: number): string {
   return text.length > max ? `${text.slice(0, max - 1)}…` : text
 }
+
+function plural(n: number, noun: string): string {
+  return `${n} ${noun}${n === 1 ? "" : "s"}`
+}

package/src/tui/index.tsx

@@ -8,7 +8,7 @@ import { Show, createEffect, createMemo, createSignal, on } from "solid-js"
 import { bandFor, contextSizeOf, formatContext, formatK, type MinimalMessage, type MinimalPart } from "../core/tokens.js"
 import { JournalStore, type StorageMode } from "../shared/store.js"
 import { debug } from "../shared/debug.js"
-import { BRANCH_DIALOG, MERGE_TRUST, bumpJournal, clip, createNamedBranch, journalRevision, mergeBranch, mergeDialogOptions, mergeDialogTitle, setLabel, type MergeMode } from "./actions.js"
+import { BRANCH_DIALOG, MERGE_TRUST, TRUNK_LABEL, bumpJournal, clip, createNamedBranch, journalRevision, mergeBranch, mergeDialogOptions, mergeDialogTitle, mergeTargetOf, ownTurnCount, setLabel, type MergeMode } from "./actions.js"
 import { openSiblings } from "../core/decision.js"
 import { hasEditor } from "./editor.js"
 import { TreeRoute } from "./route.js"
@@ -228,12 +228,16 @@ const tui: TuiPlugin = async (api, rawOptions) => {
             api.ui.toast({ message: "not on an open branch — /branch first" })
             return
           }
+          // the parent is usually not the loaded session, so its turn/token figures come over the SDK
+          const parent = await fetchTranscript(api, branch.parentSessionID, directory).catch(() => undefined)
+          const parentLabel = branch.parentSessionID === state.root ? TRUNK_LABEL : (state.sessions[branch.parentSessionID]?.name ?? TRUNK_LABEL)
+          const turns = ownTurnCount(api.state.session.messages(sessionID), { messageID: branch.anchorMessageID, parentMessageIDs: parent?.messages.map((m) => m.id) ?? [] })
           const mode = await new Promise<MergeMode | undefined>((resolve) => {
             api.ui.dialog.replace(
               () =>
                 api.ui.DialogSelect<MergeMode>({
-                  title: mergeDialogTitle(branch.name ?? "branch", api.state.session.get(branch.parentSessionID)?.title),
-                  options: mergeDialogOptions({ siblings: openSiblings(state, sessionID).length }),
+                  title: mergeDialogTitle(branch.name ?? "branch", parent ? mergeTargetOf(parentLabel, parent.messages) : undefined),
+                  options: mergeDialogOptions({ siblings: openSiblings(state, sessionID).length, turns }),
                   onSelect: (o) => {
                     resolve(o.value)
                     api.ui.dialog.clear()
@@ -314,6 +318,9 @@ const tui: TuiPlugin = async (api, rawOptions) => {
           return store.stateForSession(props.session_id)
         })
         const branch = () => st()?.sessions[props.session_id]
+        // the gauge's own string, so the card and the prompt line never show two numbers
+        const size = createMemo(() => contextSizeOf(toMinimalMessages(api.state.session.messages(props.session_id), api.state.part)))
+        const limit = createMemo(() => modelContextLimit(api, props.session_id))
         const crops = () => st()?.activeCrops(props.session_id) ?? []
         const hidden = () => crops().reduce((s, c) => s + c.targets.reduce((x, y) => x + y.estTokens, 0), 0)
         const siblings = () => Object.values(st()?.sessions ?? {}).filter((b) => b.parentSessionID === props.session_id && b.status === "open").length
@@ -334,6 +341,7 @@ const tui: TuiPlugin = async (api, rawOptions) => {
               <text fg={t.success}>{`⎇ ${branchLabel(api, props.session_id, branch()!.name, CARD_COLUMNS - 2)}`}</text>
               <text fg={t.textMuted}>{status()}</text>
             </Show>
+            <text fg={t[BAND_COLOR[bandFor(size().tokens, limit())]]}>{formatContext(size(), limit())}</text>
             <Show when={crops().length}>
               <text fg={t.warning}>{`✂ ${crops().length} crop${crops().length === 1 ? "" : "s"} · ~${formatK(hidden())} hidden`}</text>
             </Show>
@@ -344,13 +352,13 @@ const tui: TuiPlugin = async (api, rawOptions) => {
       session_prompt_right: (_ctx, props: { session_id: string }) => {
         const t = api.theme.current
         const size = createMemo(() => contextSizeOf(toMinimalMessages(api.state.session.messages(props.session_id), api.state.part)))
-        const band = () => bandFor(size().tokens)
         const branch = () => {
           journalRevision() // the journal is plain files: without the revision `⎇ name` never refreshes
           return store.stateForSession(props.session_id)?.sessions[props.session_id]
         }
-        // model context limit + compaction reserve, for the guard (DESIGN.md §6.7)
+        // model context limit + compaction reserve, for the bands and the guard (DESIGN.md §6.7)
         const limit = createMemo(() => modelContextLimit(api, props.session_id))
+        const band = () => bandFor(size().tokens, limit())
         const reserve = () => (api.state.config as { compaction?: { reserved?: number } }).compaction?.reserved ?? 16_384
         // trend + attribution: an effect compares each new size with the previous one
         // (side effects and closure state stay out of the memo graph)
@@ -401,7 +409,7 @@ const tui: TuiPlugin = async (api, rawOptions) => {
           const b = band()
           if (b === "red" && !redNudged) {
             redNudged = true
-            api.ui.toast({ variant: "warning", message: "context is in the red band (≥64k) — consider /tree → c crop, or /merge a branch", duration: 6000 })
+            api.ui.toast({ variant: "warning", message: `context is in the red band (${limit() ? "≥85% of the window" : "≥64k"}) — consider /tree → c crop, or /merge a branch`, duration: 6000 })
           } else if (b === "low" || b === "healthy") redNudged = false
           const lim = limit()
           if (lim && size().tokens >= lim - reserve() && !guardNudged) {