@leftoff/cli 0.8.6 → 0.8.8

package/mod/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "leftoff",
-  "version": "0.8.6",
+  "version": "0.8.8",
   "description": "Leftoff (formerly Checkpoints): WTF was I working on? Tracks every Claude Code session on this machine, writes a 3-line checkpoint when one goes quiet, and adds /cp (checkpoint now), /cp-name and a /leftoff pane. Talks to the local Leftoff daemon on 127.0.0.1:7429 and falls back to writing markdown in ~/checkpoints.",
   "author": {
     "name": "Joel"

package/mod/hooks/core.js

@@ -298,7 +298,8 @@ const CP_ORDER = ['id', 'session_id', 'session_title', 'created_at', 'trigger',
 export function resumeCommand(session) {
   const id = session.id || session.sessionId
   const cwd = resumeDir(session)
-  return (cwd ? 'cd ' + shArg(cwd) + ' && ' : '') + (isCodex(session) ? codexInvocation(id) : claudeInvocation(session, ['--resume', id]))
+  const wt = resumeWorktreeName(session)
+  return (cwd ? 'cd ' + shArg(cwd) + ' && ' : '') + (isCodex(session) ? codexInvocation(id) : claudeInvocation(session, [...(wt ? ['--worktree', wt] : []), '--resume', id]))
 }
 
 // 0.8.0: a Codex session (its rollout under ~/.codex/sessions) resumes with `codex resume <id>`.
@@ -308,9 +309,24 @@ export function codexInvocation(id) { return 'codex resume ' + shArg(id) }
 // 0.7.1: where to run `claude --resume`: the session's folder, or, inside a git
 // worktree, that worktree's own top folder (Claude Code declines to re-enter a
 // `git worktree add` worktree from one of its subfolders; code.claude.com/docs/en/worktrees).
+//
+// 0.8.8: a worktree Claude Code made (<repo>/.claude/worktrees/<name>, from
+// `claude --worktree` or EnterWorktree) is resumed the way Claude Code itself
+// prints on exit: from the main checkout, `claude --worktree <name> --resume <id>`.
+// On exit Claude Code moves the session back to where it was launched and
+// clears its worktree binding, so --worktree is what puts it back in there.
+// Not when the worktree is gone (folderGone): --worktree would make a new one.
+export function resumeWorktreeName(session) {
+  const wt = session && session.repo && session.repo.worktree
+  const root = session && session.repo && session.repo.root
+  if (!wt || !root || typeof wt !== 'string' || session.folderGone || isCodex(session)) return null
+  const c = claudeWorktreeOf(wt)
+  return c && trimSlash(c.root) === trimSlash(root) && trimSlash(c.path) === trimSlash(wt) ? c.name : null
+}
 export function resumeDir(session) {
   const cwd = session && session.cwd
   const wt = session && session.repo && session.repo.worktree
+  if (resumeWorktreeName(session)) return session.repo.root
   if (cwd && wt && typeof wt === 'string' && (cwd === wt || String(cwd).startsWith(wt.replace(/\/+$/, '') + '/'))) return wt
   return cwd || null
 }
@@ -821,9 +837,14 @@ export function applyEvent(s, ev) {
   // replayed older events (a Codex rollout read again) don't.
   if (s.parked && ms(at) > ms(s.parked.at) && unparks(s, ev, d)) delete s.parked
   switch (ev.type) {
-    case 'session.parked':
+    case 'session.parked': {
+      const prevLock = s.parked && s.parked.worktreeLock // parked again: the lock it already holds stays on record
       s.parked = { at, note: d.note ? clip(String(d.note).replace(/\s+/g, ' ').trim(), 300) || null : null, checkpoint: d.checkpoint ? String(d.checkpoint) : null, by: d.by ? String(d.by) : null }
+      // 0.8.8: the worktree /cp-park (or Park) locked, so it can be unlocked later
+      if (d.worktreeLock && typeof d.worktreeLock === 'object' && typeof d.worktreeLock.path === 'string' && typeof d.worktreeLock.reason === 'string') s.parked.worktreeLock = { path: d.worktreeLock.path, root: typeof d.worktreeLock.root === 'string' ? d.worktreeLock.root : null, reason: d.worktreeLock.reason }
+      else if (prevLock) s.parked.worktreeLock = prevLock
       break
+    }
     case 'session.unparked':
       delete s.parked
       break
@@ -912,6 +933,137 @@ export function parseParkArgs(args) {
   return { note: note ? clip(note, 300) : null }
 }
 
+// ------------------------------------------------------------ parked worktrees (0.8.8)
+// Claude Code removes a session's worktree when the session exits and the
+// worktree has no changes (code.claude.com/docs/en/worktrees, "Clean up
+// worktrees"), and /cp-park exits. So in a linked git worktree, park first
+// locks it (`git worktree lock --reason …`). Claude Code's exit cleanup keeps a
+// worktree locked with a reason it didn't write, and its stale-lock sweep only
+// releases its own "claude agent|session … (pid N)" locks, so the reason must
+// never start with "claude ". Resume, Done with it, or the session coming back
+// unlocks it. Only a lock with this exact session's reason is ever unlocked.
+// run(argv) -> { code | exitCode, stdout, stderr }: $.process.run in the mod,
+// execFile in the daemon, a fake in tests. Nothing here deletes anything.
+export const PARK_LOCK_PREFIX = 'leftoff: parked session '
+export function parkLockReason(sessionId) {
+  return PARK_LOCK_PREFIX + String(sessionId || '') + ' (resume it, or press Done with it on the board, to unlock)'
+}
+// a lock reason -> the session id Leftoff parked, or null for any other lock
+export function parkLockSession(reason) {
+  const m = /^leftoff: parked session ([A-Za-z0-9-]{4,80})(?: |$)/.exec(String(reason == null ? '' : reason))
+  return m ? m[1] : null
+}
+
+// `git worktree list --porcelain` -> [{ path, branch, bare, detached, locked: null | reason ('' when none given) }]
+export function parseWorktreeList(text) {
+  const out = []
+  let cur = null
+  for (const raw of String(text || '').split('\n')) {
+    const line = raw.replace(/\r$/, '')
+    if (line.startsWith('worktree ')) { cur = { path: line.slice(9), branch: null, bare: false, detached: false, locked: null }; out.push(cur); continue }
+    if (!cur) continue
+    if (line.startsWith('branch ')) cur.branch = line.slice(7).replace(/^refs\/heads\//, '')
+    else if (line === 'bare') cur.bare = true
+    else if (line === 'detached') cur.detached = true
+    else if (line === 'locked') cur.locked = ''
+    else if (line.startsWith('locked ')) cur.locked = line.slice(7)
+  }
+  return out
+}
+
+const runCode = (r) => (r == null ? null : r.code != null ? r.code : r.exitCode != null ? r.exitCode : null)
+const trimSlash = (p) => String(p || '').replace(/\/+$/, '') || '/'
+const firstLine = (s) => String(s || '').trim().split('\n')[0].slice(0, 200)
+// a path inside Claude Code's own worktrees folder: <repo>/.claude/worktrees/<name>[/…]
+export function claudeWorktreeOf(dir) {
+  const m = /^(.*)\/\.claude\/worktrees\/([^/]+)(?:\/.*)?$/.exec(trimSlash(dir))
+  return m ? { root: m[1] || '/', name: m[2], path: m[1] + '/.claude/worktrees/' + m[2] } : null
+}
+
+// Is dir in a linked git worktree? -> { kind: 'worktree', top, root, gitDir, commonDir }
+// | { kind: 'none' } (not in git, or the main checkout) | { kind: 'unknown', why }
+export async function worktreeAt(run, dir) {
+  if (!dir) return { kind: 'unknown', why: 'no folder on record' }
+  let r
+  try { r = await run(['git', '-C', dir, 'rev-parse', '--path-format=absolute', '--git-dir', '--git-common-dir', '--show-toplevel']) } catch (e) { return { kind: 'unknown', why: 'git didn’t run (' + firstLine(e && e.message) + ')' } }
+  if (runCode(r) !== 0) {
+    if (/not a git repository/i.test(String(r && r.stderr))) return claudeWorktreeOf(dir) ? { kind: 'unknown', why: 'git doesn’t see a repository there' } : { kind: 'none' }
+    return { kind: 'unknown', why: 'git: ' + (firstLine(r && r.stderr) || 'exit ' + runCode(r)) }
+  }
+  const [gitDir, commonDir, top] = String(r.stdout || '').trim().split('\n').map((x) => trimSlash(x.trim()))
+  if (!gitDir || !commonDir || !top) return { kind: 'unknown', why: 'git gave no answer' }
+  if (gitDir === commonDir) return { kind: 'none' } // the main checkout (or a submodule, its own repo)
+  return { kind: 'worktree', top, gitDir, commonDir, root: /\/\.git$/.test(commonDir) ? commonDir.slice(0, -5) || '/' : commonDir }
+}
+
+function findEntry(list, path, reason) {
+  const p = trimSlash(path)
+  return list.find((e) => trimSlash(e.path) === p) || (reason ? list.find((e) => e.locked === reason) : null) || null
+}
+
+// /cp-park (and Park on the board): lock the worktree dir is in, then read it
+// back. -> { worktree: null } (not a worktree: nothing to protect)
+//  | { worktree, root, locked: true, reason } (locked and checked)
+//  | { worktree, root?, locked: false, why } (not protected: don't exit for them)
+export async function lockForPark(run, dir, sessionId) {
+  const w = await worktreeAt(run, dir)
+  if (w.kind === 'none') return { worktree: null }
+  if (w.kind === 'unknown') { const g = claudeWorktreeOf(dir); return { worktree: g ? g.path : null, locked: false, why: w.why, unsure: true } }
+  const reason = parkLockReason(sessionId)
+  let lockErr = ''
+  try { const r = await run(['git', '-C', w.top, 'worktree', 'lock', '--reason', reason, w.top]); if (runCode(r) !== 0) lockErr = firstLine(r && r.stderr) || 'exit ' + runCode(r) } catch (e) { lockErr = firstLine(e && e.message) }
+  let list = null
+  try { const l = await run(['git', '-C', w.top, 'worktree', 'list', '--porcelain']); if (runCode(l) === 0) list = parseWorktreeList(l.stdout) } catch {}
+  const base = { worktree: w.top, root: w.root }
+  if (!list) return { ...base, locked: false, why: 'couldn’t read the lock back' + (lockErr ? ' (' + lockErr + ')' : '') }
+  const e = findEntry(list, w.top, reason)
+  if (e && e.locked === reason) return { ...base, locked: true, reason }
+  if (e && e.locked != null) return { ...base, locked: false, why: 'it’s already locked' + (e.locked ? ' (“' + clip(e.locked, 80) + '”)' : ''), foreign: true }
+  return { ...base, locked: false, why: lockErr || 'the lock didn’t take' }
+}
+
+// Is the lock still there, with our reason? (checked again right before /exit)
+export async function parkLockHeld(run, path, reason) {
+  try {
+    const l = await run(['git', '-C', path, 'worktree', 'list', '--porcelain'])
+    if (runCode(l) !== 0) return false
+    const e = findEntry(parseWorktreeList(l.stdout), path, reason)
+    return !!(e && e.locked === reason)
+  } catch { return false }
+}
+
+// Unlock what Leftoff locked for this session: every worktree of the repo at
+// dir whose lock reason is this session's park reason. Any other lock (yours,
+// Claude Code's) is left alone. -> { unlocked: [path], failed: [{ path, why }], error? }
+export async function unlockParkLocks(run, dir, sessionId) {
+  const out = { unlocked: [], failed: [] }
+  if (!dir || !sessionId) return out
+  let list
+  try {
+    const l = await run(['git', '-C', dir, 'worktree', 'list', '--porcelain'])
+    if (runCode(l) !== 0) return { ...out, error: firstLine(l && l.stderr) || 'git worktree list failed' }
+    list = parseWorktreeList(l.stdout)
+  } catch (e) { return { ...out, error: firstLine(e && e.message) } }
+  for (const e of list) {
+    if (e.locked == null || parkLockSession(e.locked) !== String(sessionId)) continue
+    try {
+      const r = await run(['git', '-C', dir, 'worktree', 'unlock', e.path])
+      if (runCode(r) === 0) out.unlocked.push(e.path)
+      else out.failed.push({ path: e.path, why: firstLine(r && r.stderr) || 'exit ' + runCode(r) })
+    } catch (err) { out.failed.push({ path: e.path, why: firstLine(err && err.message) }) }
+  }
+  return out
+}
+
+// What /cp-park says about the worktree. res: lockForPark's answer.
+export function parkWorktreeText(res) {
+  if (!res || !res.worktree && !res.unsure) return ''
+  if (!res.worktree && !res.locked) return ' Leftoff couldn’t tell whether this is a worktree session (' + (res.why || 'no answer') + '), so it didn’t close it. If it is one, lock it first (`git worktree lock <worktree>`) or choose Keep if Claude Code asks: on /exit, Claude Code removes a worktree that has no changes.'
+  if (res.locked) return ' This is a worktree session, so Leftoff locked the worktree first: Claude Code will say it kept it (“could not be removed”). Resume or Done with it unlocks it.'
+  const where = res.worktree ? ' ' + shArg(res.worktree) : ''
+  return ' This is a worktree session and Leftoff couldn’t lock it (' + (res.why || 'no answer') + '), so it didn’t close the session: on /exit, Claude Code removes a worktree that has no changes. To keep it, run `git worktree lock' + (where || ' <worktree>') + '` first, or choose Keep if Claude Code asks.'
+}
+
 // The question Claude ended its turn on, if it ended on one: the last paragraph
 // of the answer when its last sentence ends with "?" (markdown and closing
 // quotes ignored). Code blocks don't count. -> string or null

package/mod/hooks/register.js

@@ -19,7 +19,7 @@ import {
   shortId, formatTabTitle, parseTabTitle, detectTerminal, parseProcLine, trailingQuestion,
   parseCheckpointArgs, SUMMARY_LENGTHS, parseBulletList, parseCatchupArgs,
   listHintFrom, extractChecklists, parseTodoArgs, parseDoneArgs, detectBackend, parseParkArgs,
-  boardLinkLines, isNonInteractive,
+  boardLinkLines, isNonInteractive, lockForPark, parkLockHeld, unlockParkLocks, parkWorktreeText,
 } from './core.js'
 
 const PANE_ID = 'checkpoints'
@@ -28,7 +28,7 @@ const END_TIMEOUT_MS = 1000
 const MODEL_TIMEOUT_MS = 20000
 
 // Module state. $.state is not used: the pane redraws with $.ui.invalidate.
-const MOD_VERSION = '0.8.6' // keep in step with .claude-plugin/plugin.json
+const MOD_VERSION = '0.8.8' // keep in step with .claude-plugin/plugin.json
 
 const st = {
   internal: false,
@@ -278,17 +278,45 @@ async function boardLinks($) {
 // only runs once Claude is done with the turn). If that's refused, it says to
 // type /exit. Nothing is ever killed.
 const PARK_FALLBACK = 'Parked. Type /exit when you\'re ready, and it\'ll stay on your board.'
+const PARK_LOCK_LOST = 'Parked, but not closed: the worktree lock Leftoff took is gone, and on /exit Claude Code removes a worktree that has no changes. Lock it again (git worktree lock), or choose Keep if Claude Code asks.'
+// 0.8.8: argv -> { exitCode, stdout, stderr } for the worktree helpers in core.js
+async function gitFor($, argv) { return $.process.run(argv, { timeoutMs: 5000 }) }
 async function parkCommand($, args) {
   if (st.internal || !st.sessionId) return { text: 'Leftoff: not in a tracked session.' }
   const a = parseParkArgs(args)
+  // 0.8.8: in a git worktree, lock it first: Claude Code's exit removes a worktree
+  // with no changes, and parking means coming back. No lock, no automatic /exit.
+  let cwd = null
+  try { cwd = await $.session.cwd() } catch {}
+  cwd = cwd || (st.record && st.record.cwd) || null
+  const run = (argv) => gitFor($, argv)
+  const wt = cwd ? await lockForPark(run, cwd, st.sessionId).catch((e) => ({ worktree: null, locked: false, unsure: true, why: String(e && e.message) })) : { worktree: null, locked: false, unsure: true, why: 'no folder on record' }
   const cp = await makeCheckpoint($, 'park', a.note, null, { next: a.note })
-  if (!cp) return { text: 'Leftoff: a checkpoint is already being made. Try /cp-park again in a moment.' }
-  await sendOrSpool($, 'session.parked', { note: a.note, checkpoint: cp.id || null, by: 'command' })
-  // After this command returns, not inside it: the built-in /exit.
+  if (!cp) {
+    if (wt.locked) await unlockParkLocks(run, wt.root || wt.worktree, st.sessionId).catch(() => null) // not parked after all
+    return { text: 'Leftoff: a checkpoint is already being made. Try /cp-park again in a moment.' }
+  }
+  const worktreeLock = wt.locked ? { path: wt.worktree, root: wt.root || null, reason: wt.reason } : null
+  await sendOrSpool($, 'session.parked', { note: a.note, checkpoint: cp.id || null, by: 'command', ...(worktreeLock ? { worktreeLock } : {}) })
+  const head = 'Parked' + (a.note ? ': ' + clip(a.note, 120) : '') + '.'
+  if (wt.worktree || wt.unsure) {
+    if (!wt.locked) return { text: head + parkWorktreeText(wt) }
+  }
+  // After this command returns, not inside it: the built-in /exit (in a worktree, only while our lock still holds).
   $.clock.after(400, async () => {
+    if (worktreeLock && !(await parkLockHeld(run, worktreeLock.path, worktreeLock.reason))) { try { $.ui.toast(PARK_LOCK_LOST, { timeoutMs: 12000 }) } catch {} return }
     try { await $.command.run({ command: 'exit' }) } catch { try { $.ui.toast(PARK_FALLBACK, { timeoutMs: 8000 }) } catch {} }
   })
-  return { text: 'Parked' + (a.note ? ': ' + clip(a.note, 120) : '') + '. Closing this session; it stays on your board under Parked.' }
+  return { text: head + ' Closing this session; it stays on your board under Parked.' + parkWorktreeText(wt) }
+}
+
+// 0.8.8: this session is back (claude --resume, or --worktree <name> --resume):
+// unlock any worktree Leftoff locked when it was parked. Only its own lock.
+async function unlockOwnParkLocks($, cwd) {
+  if (st.internal || !st.sessionId || !cwd) return
+  try {
+    await unlockParkLocks((argv) => gitFor($, argv), cwd, st.sessionId)
+  } catch {}
 }
 
 // ------------------------------------------------------------ lists (v0.5.1)
@@ -901,6 +929,7 @@ export function register(on, options) {
       st.backend = await readBackend($, model)
       st.hello = { cwd, repo, model, backend: st.backend, surface, proc: st.proc ? { ...st.proc, source: 'mod' } : null, term: st.term }
       await sendOrSpool($, 'session.opened', st.hello)
+      if (repo) await unlockOwnParkLocks($, cwd) // 0.8.8
       if (st.heartbeat) st.heartbeat.cancel()
       st.heartbeat = $.clock.every(60000, () => { heartbeat($).catch(() => {}); startReplyLoop($) })
       st.ready = true
@@ -923,6 +952,7 @@ export function register(on, options) {
         st.lastCheckpoint = null
         st.titleSoon = false
         st.daemonTitle = null
+        if (e.source === 'resume' && e.cwd) await unlockOwnParkLocks($, e.cwd) // 0.8.8: /resume of a parked worktree session
       }
       if (!st.sessionId) st.sessionId = e.session_id
       await sendOrSpool($, 'session.started', {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leftoff/cli",
-  "version": "0.8.6",
+  "version": "0.8.8",
   "description": "Leftoff: WTF was I working on? Tracks every Claude Code session, writes a 3-line checkpoint when one goes quiet, and gives you a daily digest and a board, on your Mac and (optionally) your phone.",
   "keywords": [
     "claude",

package/ui/app.css

@@ -1630,3 +1630,26 @@ html.dv-open, html.dv-open body { overflow: hidden; }
   .emoji-sheet-wrap { align-items: flex-end; }
   .emoji-sheet { width: 100vw; border-radius: 16px 16px 0 0; padding-bottom: calc(14px + env(safe-area-inset-bottom)); }
 }
+
+/* 0.8.7: a card's actions are one row: main button, copy icon, ⋯ (the rest in a menu) */
+.card > .actions-row { flex-wrap: nowrap; align-items: center; min-width: 0; }
+.card > .actions-row > .btn:not(.icon-btn), .card > .actions-row > .go-off { min-width: 0; flex: 0 1 auto; }
+.card > .actions-row > .btn:not(.icon-btn) { overflow: hidden; text-overflow: ellipsis; white-space: nowrap; display: inline-block; line-height: 1.45; }
+.card > .actions-row > .btn:not(.icon-btn) .ic { vertical-align: -2px; margin-right: 5px; }
+.card > .actions-row > .go-off { display: inline-flex; align-items: center; gap: 6px; overflow: hidden; }
+.card > .actions-row > .go-off .why { overflow: hidden; text-overflow: ellipsis; white-space: nowrap; min-width: 0; }
+.card > .actions-row > .ro { flex: 1 1 auto; min-width: 0; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+.btn.icon-btn { flex: none; width: 30px; height: 28px; padding: 0; justify-content: center; }
+.btn.icon-btn .ic { width: 15px; height: 15px; margin: 0; }
+.card > .actions-row > .btn.more { margin-left: auto; }
+.btn.copy-resume.copied { color: var(--green, #2fbf71); border-color: currentColor; }
+.lo-actmenu { min-width: 190px; max-width: min(320px, calc(100vw - 16px)); overflow-y: auto; }
+.lo-act { display: flex; align-items: center; gap: 10px; width: 100%; padding: 8px 10px; border: 0; border-radius: 8px; background: none; color: var(--text2); font: inherit; font-size: 14px; text-align: left; cursor: pointer; white-space: nowrap; }
+.lo-act .ic { width: 16px; height: 16px; flex: none; color: var(--muted); }
+.lo-act:hover, .lo-act:focus { outline: none; background: var(--bg2); color: var(--text); }
+[data-theme="dark"] .lo-act:hover, [data-theme="dark"] .lo-act:focus, :root:not([data-theme="light"]) .lo-act:hover, :root:not([data-theme="light"]) .lo-act:focus { background: var(--line); }
+.lo-act:focus-visible { box-shadow: inset 0 0 0 2px var(--focus); }
+.lo-act:disabled { opacity: .55; cursor: progress; }
+.lo-menu.sheet.lo-actmenu { max-width: none; }
+.lo-menu.sheet .lo-act { padding: 14px 10px; font-size: 16px; }
+@media (pointer: coarse) { .btn.icon-btn { width: 36px; height: 34px; } }

package/ui/app.js

@@ -2,7 +2,7 @@
 // /v1 API on the same origin (auth rides the cookie set at GET /).
 import { goWithFeedback, goState, GIVE_UP_MS } from './go.js'
 import { icon } from './icons.js'
-import { selectHtml, comboHtml, closeMenu } from './picker.js'
+import { selectHtml, comboHtml, closeMenu, openActionMenu, closeActionMenu, actionMenuKey } from './picker.js'
 import { SETTINGS, settingsKeyFor } from './settings-nav.js'
 import { inStatus, repoChips, applyFilter, readFilter, saveRepos, filterHash, toggleRepo, chipSelected, splitChips, repoMatches, orderSelectedFirst, searchMatches } from './repos.js'
 import { needsItems, needsStrip, needPanel, agentNeedPanel, httpsOnly, agentReplyButton, agentChipHtml, cardBadge, questionAnswer, turnsHtml, dismissedHtml } from './needs.js'
@@ -98,7 +98,13 @@ function toastUndo(msg, onUndo, ms = 5000) {
   toast.t = setTimeout(() => t.classList.remove('show', 'has-action'), ms)
 }
 async function copy(text) {
-  try { await navigator.clipboard.writeText(text); toast('Copied: ' + text) } catch { prompt('Copy this:', text) }
+  try { await navigator.clipboard.writeText(text); toast('Copied: ' + text); return true } catch { prompt('Copy this:', text); return false }
+}
+// 0.8.7: the copy icon says it worked for a moment (a check, "Copied"), then goes back.
+function copiedMark(btn) {
+  clearTimeout(btn._copied)
+  btn.classList.add('copied'); btn.innerHTML = icon('check'); btn.setAttribute('aria-label', 'Copied'); btn.title = 'Copied'
+  btn._copied = setTimeout(() => { btn.classList.remove('copied'); btn.innerHTML = icon('copy'); btn.setAttribute('aria-label', 'Copy resume command'); btn.title = 'Copy resume command' }, 1500)
 }
 const pill = (status) => '<span class="pill s-' + esc(status) + '">' + esc(LABEL[status] || status) + '</span>'
 
@@ -402,8 +408,44 @@ function agentCard(s) {
     agentListChips(s) + (n ? cardBadge(n) : '') + agentCpBlock(s.latestCheckpoint) +
     '<a class="cplink" href="' + href + '">' + (s.checkpointCount ? s.checkpointCount + (s.checkpointCount === 1 ? ' checkpoint' : ' checkpoints') : 'Session') + ' →</a>' +
     '<div class="actions-row">' + (n ? agentReplyButton(a, 'btn') : '') +
-      '<span class="ro">read-only · from ' + esc(a.display || a.name) + '’s feed</span></div></article>'
+      roNote('read-only · from ' + (a.display || a.name) + '’s feed') + '</div></article>'
+}
+
+// 0.8.7: a card's actions are one row: its main button (Go, or Resume once it's
+// closed), a small copy icon for the resume command, and "⋯" for the rest. The
+// ⋯ menu's items ride in the card as an inert <template> (real buttons with the
+// same data-action as before), so the one click handler below runs them unchanged.
+function copyResumeIcon(s) {
+  return '<button type="button" class="btn icon-btn copy-resume" data-action="resume" data-id="' + esc(s.id) + '" aria-label="Copy resume command" title="Copy resume command">' + icon('copy') + '</button>'
+}
+// items: [{ action, label, icon, title, attrs }]
+function moreMenu(s, items) {
+  items = items.filter(Boolean)
+  if (!items.length) return ''
+  return '<button type="button" class="btn icon-btn more" data-action="card-more" data-id="' + esc(s.id) + '" aria-label="More actions" title="More actions" aria-haspopup="menu" aria-expanded="false">' + icon('ellipsis') + '</button>' +
+    '<template class="more-items">' + items.map((it) => '<button type="button" data-action="' + esc(it.action) + '" data-id="' + esc(s.id) + '"' +
+      Object.entries(it.attrs || {}).map(([k, v]) => ' ' + k + '="' + esc(v) + '"').join('') + (it.title ? ' title="' + esc(it.title) + '"' : '') + '>' +
+      (it.icon ? icon(it.icon) : '') + esc(it.label) + '</button>').join('') + '</template>'
+}
+function openCardMenu(btn) {
+  const tpl = btn.parentElement && btn.parentElement.querySelector('template.more-items')
+  if (!tpl) return
+  const card = btn.closest('.card')
+  const title = card && card.querySelector('.title a') ? card.querySelector('.title a').textContent.trim() : ''
+  const items = [...tpl.content.querySelectorAll('button')].map((b) => {
+    const svg = b.querySelector('svg')
+    const attrs = {}
+    for (const a of b.attributes) if (a.name.startsWith('data-') || a.name === 'title') attrs[a.name] = a.value
+    return { label: b.textContent.trim(), icon: svg ? svg.outerHTML : '', attrs }
+  })
+  openActionMenu(btn, items, { title })
 }
+const sessionMenuItems = (s) => s.isLocal ? [
+  { action: 'checkpoint', label: 'Checkpoint now', icon: 'bookmark-plus' },
+  { action: 'pin', label: s.pinned ? 'Unpin' : 'Pin', icon: s.pinned ? 'pin-off' : 'pin' },
+  { action: 'archive', label: 'Archive', icon: 'archive' },
+] : []
+const roNote = (t) => '<span class="ro" title="' + esc(t) + '">' + esc(t) + '</span>'
 
 function card(s) {
   if (s.agent) return agentCard(s)
@@ -419,11 +461,9 @@ function card(s) {
       (s.needsInput && s.lastNotification && !s.needsYou ? '<span class="chip">' + esc(s.lastNotification.replace(/_/g, ' ')) + '</span>' : '') + '</div>' +
     cardPrsHtml(s.prs) + listChips(s) + cardHandoffChips(s) + nb + cpBlock(s.latestCheckpoint) +
     '<a class="cplink" href="#/s/' + encodeURIComponent(s.id) + '">' + (s.checkpointCount ? s.checkpointCount + (s.checkpointCount === 1 ? ' checkpoint' : ' checkpoints') : 'Session history') + ' →</a>' +
-    '<div class="actions-row">' + goButton(s) +
-      '<button type="button" class="btn" data-action="resume">Copy resume</button>' +
-      (s.isLocal ? '<button type="button" class="btn" data-action="checkpoint">Checkpoint now</button>' +
-        '<button type="button" class="btn" data-action="pin">' + (s.pinned ? 'Unpin' : 'Pin') + '</button>' +
-        '<button type="button" class="btn" data-action="archive">Archive</button>' : '<span class="ro">' + (s.peer && s.peer.ok ? 'lives on ' + esc(s.machine) + ' · answering and Go work through it' : 'read-only here · lives on ' + esc(s.machine)) + '</span>') +
+    '<div class="actions-row">' + (goButton(s) || (s.status === 'ended' || s.live === 'closed' ? resumeButton(s, s.viewer || { local: state.viewerLocal !== false, ghostty: !!state.ghostty }) : '')) +
+      copyResumeIcon(s) +
+      (s.isLocal ? moreMenu(s, sessionMenuItems(s)) : roNote(s.peer && s.peer.ok ? 'lives on ' + s.machine + ' · answering and Go work through it' : 'read-only here · lives on ' + s.machine)) +
     '</div></article>'
 }
 
@@ -669,9 +709,8 @@ function closedCard(s, viewer) {
       '<span class="chip machine' + (s.isLocal ? '' : ' remote') + '" title="' + (s.isLocal ? 'this machine' : 'another machine') + '">⌂ ' + esc(s.machine) + '</span>' + modelChip(s) +
       '<span title="' + esc(clock(s.endedAt)) + '">ended ' + esc(ago(s.endedAt)) + '</span><span>·</span><span>' + esc(s.turns) + (s.turns === 1 ? ' turn' : ' turns') + '</span></div>' +
     cardHandoffChips(s) + cpBlock(s.latestCheckpoint, { showWhen: false }) +
-    '<div class="actions-row">' + resumeButton(s, viewer) +
-      '<button type="button" class="btn" data-action="resume" data-id="' + esc(s.id) + '">Copy resume</button>' +
-      '<a class="btn" href="' + href + '">' + (s.checkpointCount ? s.checkpointCount + (s.checkpointCount === 1 ? ' checkpoint' : ' checkpoints') : 'Details') + ' →</a>' +
+    '<div class="actions-row">' + resumeButton(s, viewer) + copyResumeIcon(s) +
+      moreMenu(s, [{ action: 'open-href', label: s.checkpointCount ? s.checkpointCount + (s.checkpointCount === 1 ? ' checkpoint' : ' checkpoints') : 'Details', icon: 'history', attrs: { 'data-href': href } }]) +
     '</div></article>'
 }
 function closedRepaint() {
@@ -743,9 +782,8 @@ function parkedCard(s, viewer) {
       (s.isLocal ? '' : '<span class="chip machine remote" title="another machine">⌂ ' + esc(s.machine) + '</span>') + modelChip(s) +
       '<span title="' + esc(clock(p.at)) + '">parked ' + esc(ago(p.at)) + '</span>' + (open ? '<span>·</span><span>still open</span>' : '') + '</div>' +
     (note ? '<div class="park-note"><span class="k">' + (p.note ? 'Note' : 'Next') + '</span> ' + esc(note) + '</div>' : '') +
-    '<div class="actions-row">' + main +
-      (open ? '' : '<button type="button" class="btn" data-action="resume" data-id="' + esc(s.id) + '">Copy resume</button>') +
-      '<button type="button" class="linkish park-done" data-action="unpark" data-id="' + esc(s.id) + '" title="No longer parked' + (open ? '' : '; it goes to Closed') + '">Done with it</button>' +
+    '<div class="actions-row">' + main + (open ? '' : copyResumeIcon(s)) +
+      moreMenu(s, [{ action: 'unpark', label: 'Done with it', icon: 'circle-check', title: 'No longer parked' + (open ? '' : '; it goes to Closed') }]) +
     '</div></article>'
 }
 // The session page's Park row (0.8.2): any open session, Codex too, with an
@@ -2983,6 +3021,12 @@ document.addEventListener('input', (ev) => {
 })
 document.addEventListener('keydown', (ev) => { if (ev.target.id === 'prs-q' && ev.key === 'Escape' && ev.target.value) { ev.preventDefault(); ev.target.value = ''; ev.target.dispatchEvent(new Event('input', { bubbles: true })) } })
 
+window.addEventListener('hashchange', () => closeActionMenu())
+// 0.8.7: a card's ⋯ opens from the keyboard with the arrows too (Enter and Space click it).
+document.addEventListener('keydown', (ev) => {
+  const b = ev.target && ev.target.closest && ev.target.closest('[data-action="card-more"]')
+  if (b) actionMenuKey(b, ev, () => openCardMenu(b))
+})
 document.addEventListener('click', async (ev) => {
   const btn = ev.target.closest('[data-action]')
   if (!btn) return
@@ -3289,11 +3333,13 @@ document.addEventListener('click', async (ev) => {
       try { await api('POST', '/v1/needs/restore', action === 'need-restore-all' ? { all: true } : { key: btn.dataset.need }); toast(action === 'need-restore-all' ? 'Restored' : 'Restored to Needs you') } catch (e) { toast(e.message, 5000); btn.disabled = false; return }
       return render()
     }
+    if (action === 'card-more') { ev.preventDefault(); return openCardMenu(btn) }
+    if (action === 'open-href') { location.hash = btn.dataset.href; return }
     if (action === 'go') return goClick(btn, id, s)
     if (action === 'resume-open') { const ok = await resumeOpen(btn, btn.dataset.id || id); if (ok && btn.closest('.parked-card')) await render(); return ok }
     if (action === 'unpark') {
       btn.disabled = true
-      try { const r = await api('POST', '/v1/sessions/' + encodeURIComponent(btn.dataset.id || id) + '/park', { done: true }); toast(r.session && r.session.status === 'ended' ? 'Done with it · moved to Closed' : 'No longer parked') } catch (e) { toast(e.message, 5000); btn.disabled = false; return }
+      try { const r = await api('POST', '/v1/sessions/' + encodeURIComponent(btn.dataset.id || id) + '/park', { done: true }); toast((r.session && r.session.status === 'ended' ? 'Done with it · moved to Closed' : 'No longer parked') + (r.worktreeUnlocked ? ' · its worktree is unlocked (still there)' : '')) } catch (e) { toast(e.message, 5000); btn.disabled = false; return }
       return render()
     }
     if (action === 'closed-more') { closedUi.limit += CLOSED_PAGE; btn.disabled = true; try { await closedFetch(state.boardFilter || { repos: [] }, state.boardSpace); closedRepaint() } catch (e) { toast(e.message, 5000) } return }
@@ -3304,9 +3350,10 @@ document.addEventListener('click', async (ev) => {
     if (action && action.startsWith('sync-') || action === 'peer-trust') return syncAction(action, btn)
     if (action === 'resume') {
       const cmd = s ? s.resumeCommand : (await api('GET', '/v1/sessions/' + encodeURIComponent(id))).resumeCommand
-      await copy(cmd)
+      if (await copy(cmd) && btn.classList.contains('copy-resume')) copiedMark(btn)
     } else if (action === 'checkpoint') {
       btn.disabled = true; btn.textContent = 'Writing…'
+      if (!btn.isConnected) toast('Writing a checkpoint…', 20000) // from the ⋯ menu, which has closed
       const cp = await api('POST', '/v1/sessions/' + encodeURIComponent(id) + '/checkpoints', { trigger: 'manual', generate: true })
       toast('Checkpoint saved · Next: ' + cp.next)
       render()

package/ui/icons.js

@@ -31,7 +31,14 @@ export const ICONS = {
   "chevron-right": "<path d=\"m9 18 6-6-6-6\"/>",
   "chevron-left": "<path d=\"m15 18-6-6 6-6\"/>",
   "mail": "<rect width=\"20\" height=\"16\" x=\"2\" y=\"4\" rx=\"2\"/> <path d=\"m22 7-8.97 5.7a1.94 1.94 0 0 1-2.06 0L2 7\"/>",
-  "search": "<circle cx=\"11\" cy=\"11\" r=\"8\"/> <path d=\"m21 21-4.3-4.3\"/>"
+  "search": "<circle cx=\"11\" cy=\"11\" r=\"8\"/> <path d=\"m21 21-4.3-4.3\"/>",
+  "copy": "<rect width=\"14\" height=\"14\" x=\"8\" y=\"8\" rx=\"2\" ry=\"2\"/> <path d=\"M4 16c-1.1 0-2-.9-2-2V4c0-1.1.9-2 2-2h10c1.1 0 2 .9 2 2\"/>",
+  "ellipsis": "<circle cx=\"12\" cy=\"12\" r=\"1\"/> <circle cx=\"19\" cy=\"12\" r=\"1\"/> <circle cx=\"5\" cy=\"12\" r=\"1\"/>",
+  "pin": "<path d=\"M12 17v5\"/> <path d=\"M9 10.76a2 2 0 0 1-1.11 1.79l-1.78.9A2 2 0 0 0 5 15.24V16a1 1 0 0 0 1 1h12a1 1 0 0 0 1-1v-.76a2 2 0 0 0-1.11-1.79l-1.78-.9A2 2 0 0 1 15 10.76V7a1 1 0 0 1 1-1 2 2 0 0 0 0-4H8a2 2 0 0 0 0 4 1 1 0 0 1 1 1z\"/>",
+  "pin-off": "<path d=\"M12 17v5\"/> <path d=\"M15 9.34V7a1 1 0 0 1 1-1 2 2 0 0 0 0-4H7.89\"/> <path d=\"m2 2 20 20\"/> <path d=\"M9 9v1.76a2 2 0 0 1-1.11 1.79l-1.78.9A2 2 0 0 0 5 15.24V16a1 1 0 0 0 1 1h11\"/>",
+  "archive": "<rect width=\"20\" height=\"5\" x=\"2\" y=\"3\" rx=\"1\"/> <path d=\"M4 8v11a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V8\"/> <path d=\"M10 12h4\"/>",
+  "bookmark-plus": "<path d=\"m19 21-7-4-7 4V5a2 2 0 0 1 2-2h10a2 2 0 0 1 2 2v16z\"/> <path d=\"M12 7v6\"/> <path d=\"M15 10H9\"/>",
+  "circle-check": "<circle cx=\"12\" cy=\"12\" r=\"10\"/> <path d=\"m9 12 2 2 4-4\"/>"
 }
 
 export function icon(name, cls = 'ic') {

package/ui/picker.js

@@ -276,13 +276,117 @@ function onKey(host, e) {
   }
 }
 
+
+// 0.8.7: a card's "⋯" menu. Not a select: a list of actions (role menu, items
+// role menuitem). The items are real <button data-action …> elements, so the
+// board's one click handler runs them exactly as it ran the old row of buttons;
+// choosing one closes the menu. Same look as the selects' menu: under (or
+// above) the ⋯ on a desktop, a bottom sheet under 600px. Arrows, Home/End,
+// Enter/Space, Escape (focus back on the ⋯), Tab, and a tap outside closes.
+//   items: [{ label, icon (svg markup, optional), attrs: { 'data-action': …, 'data-id': … }, cls }]
+let act = null // { anchor, menu, backdrop, items }
+export function actionMenuOpen() { return !!act }
+export function closeActionMenu({ focus = false } = {}) {
+  if (!act) return
+  const { anchor, menu, backdrop } = act
+  act = null
+  menu.remove(); if (backdrop) backdrop.remove()
+  anchor.setAttribute('aria-expanded', 'false')
+  if (focus && anchor.isConnected) anchor.focus()
+}
+function placeAction() {
+  if (!act) return
+  const { menu, anchor } = act
+  const vw = document.documentElement.clientWidth, vh = (window.visualViewport && window.visualViewport.height) || window.innerHeight
+  if (menu.classList.contains('sheet')) { menu.style.maxHeight = Math.round(vh * 0.72) + 'px'; return }
+  const r = anchor.getBoundingClientRect()
+  const pad = 8
+  const w = menu.offsetWidth, h = menu.offsetHeight
+  const up = vh - r.bottom - pad < h + 6 && r.top - pad > vh - r.bottom - pad
+  // right edges line up (the ⋯ sits at the end of the row), never past the viewport
+  menu.style.left = Math.max(pad, Math.min(r.right - w, vw - pad - w)) + 'px'
+  menu.style.top = (up ? Math.max(pad, r.top - 6 - h) : r.bottom + 6) + 'px'
+  menu.classList.toggle('up', up)
+}
+function actFocus(k) {
+  if (!act) return
+  const n = act.items.length
+  if (!n) return
+  act.items[((k % n) + n) % n].focus()
+}
+export function openActionMenu(anchor, items, { title = '' } = {}) {
+  if (act && act.anchor === anchor) { closeActionMenu({ focus: true }); return null }
+  closeActionMenu(); closeMenu()
+  const sheet = narrow()
+  const id = 'lo-act' + (++uid)
+  const menu = document.createElement('div')
+  menu.className = 'lo-menu lo-actmenu' + (sheet ? ' sheet' : '')
+  menu.id = id
+  menu.setAttribute('role', 'menu')
+  if (title) menu.setAttribute('aria-label', title)
+  menu.innerHTML = (sheet && title ? '<div class="lo-sheet-head"><span>' + esc(title) + '</span><button type="button" class="lo-sheet-done" data-act-close>Done</button></div>' : '') +
+    items.map((it) => '<button type="button" role="menuitem" tabindex="-1" class="lo-act' + (it.cls ? ' ' + esc(it.cls) : '') + '"' + attrs(it.attrs || {}) + '>' + (it.icon || '') + '<span>' + esc(it.label) + '</span></button>').join('')
+  let backdrop = null
+  if (sheet) { backdrop = document.createElement('div'); backdrop.className = 'lo-backdrop'; document.body.appendChild(backdrop) }
+  document.body.appendChild(menu)
+  act = { anchor, menu, backdrop, items: [...menu.querySelectorAll('[role="menuitem"]')] }
+  anchor.setAttribute('aria-haspopup', 'menu')
+  anchor.setAttribute('aria-controls', id)
+  anchor.setAttribute('aria-expanded', 'true')
+  menu.addEventListener('click', (e) => {
+    if (e.target.closest('[data-act-close]')) { closeActionMenu({ focus: true }); return }
+    // the item's own click goes on to the board's handler (the event's path is
+    // already fixed); the menu just gets out of the way
+    if (e.target.closest('[role="menuitem"]')) closeActionMenu()
+  })
+  menu.addEventListener('mousemove', (e) => { const it = e.target.closest('[role="menuitem"]'); if (it && document.activeElement !== it) it.focus({ preventScroll: true }) })
+  menu.addEventListener('keydown', (e) => {
+    const k = act ? act.items.indexOf(document.activeElement) : -1
+    switch (e.key) {
+      case 'ArrowDown': e.preventDefault(); actFocus(k + 1); return
+      case 'ArrowUp': e.preventDefault(); actFocus(k < 0 ? -1 : k - 1); return
+      case 'Home': e.preventDefault(); actFocus(0); return
+      case 'End': e.preventDefault(); actFocus(-1); return
+      case 'Escape': e.preventDefault(); e.stopPropagation(); closeActionMenu({ focus: true }); return
+      case 'Tab': e.preventDefault(); closeActionMenu({ focus: true }); return
+      default:
+        if (e.key.length === 1 && !e.metaKey && !e.ctrlKey && !e.altKey && act) {
+          const ch = e.key.toLowerCase()
+          const j = act.items.findIndex((x, i) => i > k && x.textContent.trim().toLowerCase().startsWith(ch))
+          const j2 = j >= 0 ? j : act.items.findIndex((x) => x.textContent.trim().toLowerCase().startsWith(ch))
+          if (j2 >= 0) { e.preventDefault(); actFocus(j2) }
+        }
+    }
+  })
+  placeAction()
+  actFocus(0)
+  return menu
+}
+// the ⋯ button itself: ArrowDown/Up opens the menu too (Enter and Space click it)
+export function actionMenuKey(anchor, e, open) {
+  if (e.key === 'ArrowDown' || e.key === 'ArrowUp') { e.preventDefault(); open(); if (act && e.key === 'ArrowUp') actFocus(-1) }
+}
+
 if (typeof window !== 'undefined' && window.customElements && !customElements.get('lo-select')) {
   customElements.define('lo-select', LoSelect)
   customElements.define('lo-combo', LoCombo)
   // a click outside (or a tap on the page behind a sheet) closes; so does the page moving under a desktop menu
   document.addEventListener('pointerdown', (e) => { if (open && !open.menu.contains(e.target) && !open.host.contains(e.target)) closeMenu() }, true)
-  window.addEventListener('resize', () => { if (open) closeMenu() })
-  document.addEventListener('scroll', (e) => { if (open && !open.menu.contains(e.target)) place() }, true)
+  window.addEventListener('resize', () => { if (open) closeMenu(); if (act) closeActionMenu() })
+  document.addEventListener('scroll', (e) => { if (open && !open.menu.contains(e.target)) place(); if (act && !act.menu.contains(e.target)) placeAction() }, true)
+  // a tap outside a card's ⋯ menu closes it (and goes nowhere: a tap on the backdrop, or anywhere on a desktop page, only closes)
+  document.addEventListener('pointerdown', (e) => {
+    if (!act || act.menu.contains(e.target) || act.anchor.contains(e.target)) return
+    closeActionMenu()
+    // the click that ends this same tap is eaten; a later tap elsewhere is not
+    const x = e.clientX, y = e.clientY, at = Date.now()
+    const swallow = (ev) => {
+      document.removeEventListener('click', swallow, true)
+      if (Date.now() - at < 600 && Math.abs(ev.clientX - x) < 12 && Math.abs(ev.clientY - y) < 12) { ev.preventDefault(); ev.stopPropagation() }
+    }
+    document.addEventListener('click', swallow, true)
+    setTimeout(() => document.removeEventListener('click', swallow, true), 600)
+  }, true)
   // <label for="f-tz"> focuses (and on a click, opens) the control, as it would a select
   document.addEventListener('click', (e) => {
     const l = e.target.closest && e.target.closest('label[for]')