@leftoff/cli 0.9.18-beta.4 → 0.9.18-beta.5

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

@@ -1,6 +1,6 @@
 {
   "name": "leftoff",
-  "version": "0.9.18-beta.4",
+  "version": "0.9.18-beta.5",
   "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": "One Silly App"

package/mod/hooks/register.js

@@ -27,9 +27,12 @@ const POST_TIMEOUT_MS = 800
 const END_TIMEOUT_MS = 1000
 const MODEL_TIMEOUT_MS = 20000
 const STOP_GRACE_MS = 2500 // 2026-11-03 how long a completed turn waits for its Stop before the mod reports the end itself
+const SKIP_GRACE_MS = 4000 // 2026-11-03 how long a mod event waits for its classic twin before that classic event counts as passed over
+const START_SKIP_GRACE_MS = 15000 // the same for SessionStart (a cold start can be slow)
+const PERM_GRACE_MS = 1500 // how long a permission prompt tool.check saw waits for classic.PermissionRequest before the mod reports it
 
 // Module state. $.state is not used: the pane redraws with $.ui.invalidate.
-const MOD_VERSION = '0.9.18-beta.4' // keep in step with .claude-plugin/plugin.json
+const MOD_VERSION = '0.9.18-beta.5' // keep in step with .claude-plugin/plugin.json
 
 const st = {
   internal: false,
@@ -72,6 +75,13 @@ const st = {
   paneNeeds: 0, // sessions that need you (the pane's top line)
   turnStartAt: 0, // 2026-11-03 when this process's current turn started (turn.start)
   stopAt: 0, // and when a Stop last came (classic.Stop)
+  // 2026-11-03 Claude Code 2.1.31x passes every classic.* event of a plugin you
+  // installed over when its built-in cc-plugin-sec-default is seated first (a
+  // Team or Enterprise plan, or managed settings): see SKIP_GRACE_MS below.
+  classicSeen: false, // a classic.* hook of this mod ran in this process
+  hooksSkipped: null, // the classic events we saw passed over, as last told to the daemon
+  permAt: 0, // when classic.PermissionRequest last ran
+  watchAsks: {}, // tool_use_id -> { tool, at, reported, done }: permission prompts tool.check saw
 }
 
 // Millisecond precision: the daemon dedupes events per (sessionId, type, at).
@@ -233,7 +243,7 @@ async function readRepo($, cwd) {
 
 async function heartbeat($) {
   if (st.internal || !st.sessionId) return
-  const res = await sendOrSpool($, 'heartbeat', { inTurn: !!(st.record && st.record.inTurn) })
+  const res = await sendOrSpool($, 'heartbeat', { inTurn: !!(st.record && st.record.inTurn), ...(st.hooksSkipped && st.hooksSkipped.length ? { hooksSkipped: st.hooksSkipped } : {}) })
   if (res && !st.modHealthSent) await reportModHealth($)
   if (res && st.daemonTitle) await noteTitle($, st.daemonTitle)
   else if (res && st.tabTitle && !(st.record && st.record.inTurn)) await applyTabTitle($, null) // the marker came (it never goes: tabMarkerKept), or a rename that had to wait
@@ -256,6 +266,89 @@ async function stopFallback($, completedAt, reason) {
   await sendOrSpool($, 'turn_completed', { endReason: String(reason || 'end').slice(0, 40), settledBy: 'mod', completedAt: new Date(completedAt).toISOString() })
 }
 
+// ---------------------------------------------------------------- passed-over classic hooks (2026-11-03)
+//
+// Claude Code 2.1.31x seats its built-in "cc-plugin-sec-default" outermost on
+// a Team or Enterprise plan or a machine with managed settings, and its hooks
+// module answers every classic.* event with next.to(e, "append"): the event
+// jumps past the user tier, where a plugin you installed (this one) sits, so
+// none of our classic.* hooks run (Claude Code then says "leftoff: its
+// classic.Stop hook was skipped. "cc-plugin-sec-default" runs first and sent
+// the event on past it."). Our other events are untouched: session.start,
+// prompt.submit, turn.start, turn.complete, tool.check and tool.call.
+// So: each of those notes the classic event that should come with it; when it
+// doesn't come within the grace and no classic hook has run in this process at
+// all, the classic event counts as passed over and the daemon hears which.
+function sawClassic($, name) {
+  if (name === 'PermissionRequest') st.permAt = Date.now()
+  if (st.classicSeen) return
+  st.classicSeen = true
+  if (st.hooksSkipped && st.hooksSkipped.length) { // a slow SessionStart we counted out too early, a setting changed: they run
+    st.hooksSkipped = []
+    sendOrSpool($, 'heartbeat', { hooksSkipped: [], fromMod: true }).catch(() => {})
+  }
+}
+
+function expectClassic($, name, graceMs) {
+  if (st.classicSeen || st.internal) return
+  $.clock.after(graceMs || SKIP_GRACE_MS, () => { noteSkipped($, name).catch(() => {}) })
+}
+
+async function noteSkipped($, name) {
+  if (st.classicSeen || st.internal || !st.sessionId) return
+  const cur = st.hooksSkipped || []
+  if (cur.includes(name)) return
+  st.hooksSkipped = cur.concat(name)
+  await sendOrSpool($, 'heartbeat', { hooksSkipped: st.hooksSkipped, fromMod: true })
+}
+
+// A permission prompt, seen from tool.check: next(e) is the whole check
+// (rules, modes, other plugins' hooks, Claude Code's own), and { decision: "ask" }
+// with approver "person" is the terminal's permission dialog (a host such as
+// headless answers "host"; no approver means it is never asked). We only
+// look: the answer goes back as it came. Reported as Claude Code's own
+// permission_prompt notification would be, unless classic.PermissionRequest
+// ran for it (then permissionHook has put it on the board, answerable there).
+function watchAsk($, e) {
+  if (st.internal || st.headless || !st.sessionId) return
+  const at = Date.now()
+  const id = String(e.tool_use_id || (String(e.tool || '') + '@' + at))
+  st.watchAsks[id] = { tool: e.tool, at, reported: false, done: false }
+  expectClassic($, 'PermissionRequest')
+  $.clock.after(PERM_GRACE_MS, () => { reportAsk($, id, e).catch(() => {}) })
+}
+
+async function reportAsk($, id, e) {
+  const w = st.watchAsks[id]
+  if (!w || w.done) return
+  if (st.permAt >= w.at) { delete st.watchAsks[id]; return } // its PermissionRequest hook ran: the board has it
+  w.reported = true
+  await sendOrSpool($, 'notification', {
+    notificationType: 'permission_prompt', message: clip(askMessage(e.tool), 200), tool: e.tool || null, fromMod: true,
+    ...(st.hooksSkipped && st.hooksSkipped.length ? { hooksSkipped: st.hooksSkipped } : {}),
+  })
+}
+
+function askMessage(tool) {
+  if (tool === 'AskUserQuestion') return 'Claude has a question for you'
+  return 'Claude needs your permission to use ' + (tool || 'a tool')
+}
+
+// The prompt went away: the tool runs (tool.call) or the turn is over. Says so
+// only for prompts the mod reported (an activity the board reads as a tool
+// that ran, which ends "Needs you" for a permission prompt).
+async function settleAsks($, toolUseId, tool) {
+  let reported = false
+  for (const id of Object.keys(st.watchAsks)) {
+    const w = st.watchAsks[id]
+    if (toolUseId !== undefined && (toolUseId ? id !== String(toolUseId) : w.tool !== tool)) continue
+    w.done = true
+    if (w.reported) reported = true
+    delete st.watchAsks[id]
+  }
+  if (reported) await sendOrSpool($, 'activity', { kind: 'tool', phase: 'post', tool: tool || null, fromMod: true })
+}
+
 // The commands, in the order they're tried. Claude Code 2.1.295's built-ins
 // own /checkpoint (an alias of /rewind) and /name (an alias of /rename), so
 // ours share a /cp prefix; each command lists fallbacks in case a later
@@ -1042,6 +1135,7 @@ export function register(on, options) {
       st.heartbeat = $.clock.every(60000, () => { heartbeat($).catch(() => {}); startReplyLoop($) })
       st.ready = true
       startReplyLoop($)
+      expectClassic($, 'SessionStart', START_SKIP_GRACE_MS) // 2026-11-03 passed over? (sawClassic)
     } catch {}
     // Commands last, each on its own: a taken name throws, so a
     // clash costs only that command, and registerCommands reports it.
@@ -1050,6 +1144,7 @@ export function register(on, options) {
   })
 
   on('classic.SessionStart', async ($, e, next) => {
+    sawClassic($, 'SessionStart')
     if (!(await internalOnce($)) && !st.internal && e.session_id) {
       let parentSessionId
       if (st.sessionId && e.session_id !== st.sessionId) {
@@ -1082,6 +1177,7 @@ export function register(on, options) {
   })
 
   on('classic.UserPromptSubmit', async ($, e, next) => {
+    sawClassic($, 'UserPromptSubmit')
     await sendOrSpool($, 'activity', { kind: 'prompt', prompt: clip(e.prompt || '', 300), sessionTitle: e.session_title && e.session_title === st.tabTitle ? null : e.session_title, ...moved(e) }) // our own /rename isn't a name you chose
     return next(e)
   })
@@ -1091,6 +1187,7 @@ export function register(on, options) {
   // context entry: the list, its numbers, and `leftoff todo done <list> <n>`.
   // Context goes on the event before next(); on the result it would be too late.
   on('prompt.submit', async ($, e, next) => {
+    expectClassic($, 'UserPromptSubmit')
     const ctx = await listContextFor($)
     return next(ctx ? { ...e, context: [...(Array.isArray(e.context) ? e.context : []), ctx] } : e)
   })
@@ -1104,6 +1201,7 @@ export function register(on, options) {
   on('turn.complete', async ($, e, next) => {
     // classic.Stop reports a normal end with its details; Stop doesn't fire for
     // an interrupted or failed turn, so those are reported here.
+    await settleAsks($, undefined).catch(() => {}) // 2026-11-03 a permission prompt the mod reported is over with the turn
     if (e.reason === 'aborted' || e.reason === 'error' || e.reason === 'refusal') await sendOrSpool($, 'turn_completed', { endReason: e.reason })
     // 2026-11-03 Claude Code doesn't run every Stop for every end of a turn
     // (2.1.317: a turn its loop ends runs Stop without the in-process hooks,
@@ -1111,11 +1209,12 @@ export function register(on, options) {
     // for good. If no Stop came for this turn shortly after it completed, the
     // end is reported from here; a Stop that comes later is the same turn
     // (the daemon doesn't count it twice).
-    else { const at = Date.now(); $.clock.after(STOP_GRACE_MS, () => { stopFallback($, at, e.reason).catch(() => {}) }) }
+    else { const at = Date.now(); $.clock.after(STOP_GRACE_MS, () => { stopFallback($, at, e.reason).catch(() => {}) }); expectClassic($, 'Stop') }
     return next(e)
   })
 
   on('classic.Stop', async ($, e, next) => {
+    sawClassic($, 'Stop')
     st.stopAt = Date.now()
     // v0.5.1: a checklist of 3+ in this reply (a cheap regex, no model) -> the
     // board's card offers "Claude wrote a 7-step list · Save". Nothing is saved here.
@@ -1140,20 +1239,36 @@ export function register(on, options) {
   })
 
   on('classic.Notification', async ($, e, next) => {
+    sawClassic($, 'Notification')
     await sendOrSpool($, 'notification', { notificationType: e.notification_type || null, message: clip(e.message || '', 200), ...moved(e) })
     return next(e)
   })
 
-  on('classic.PermissionRequest', permissionHook)
+  on('classic.PermissionRequest', async ($, e, next) => { sawClassic($, 'PermissionRequest'); return permissionHook($, e, next) })
+
+  // 2026-11-03 a permission prompt, seen whether or not classic.PermissionRequest
+  // reaches us (see watchAsk): we only look, and hand the answer back as it came.
+  on('tool.check', async ($, e, next) => {
+    const r = await next(e)
+    try { if (r && r.decision === 'ask' && e && e.approver === 'person') watchAsk($, e) } catch {}
+    return r
+  })
+
+  // The tool runs: a prompt the mod reported for it was answered in the terminal.
+  on('tool.call', async ($, e, next) => {
+    if (e && Object.keys(st.watchAsks).length) await settleAsks($, e.tool_use_id || null, e.tool).catch(() => {})
+    return next(e)
+  })
 
   on('classic.PostToolUse', async ($, e, next) => {
+    sawClassic($, 'PostToolUse')
     await toolRan($, e)
     const m = moved(e) // EnterWorktree, or a cd: say so now, not at the end of the turn
     if (m.cwd || m.transcriptPath) await sendOrSpool($, 'activity', { kind: 'cwd', ...m })
     return next(e)
   })
 
-  on('classic.PostToolUseFailure', async ($, e, next) => { await toolRan($, e); return next(e) })
+  on('classic.PostToolUseFailure', async ($, e, next) => { sawClassic($, 'PostToolUseFailure'); await toolRan($, e); return next(e) })
 
   on('session.end', async ($, e, next) => {
     // About 1.5 s shared by every SessionEnd hook: post and go. The daemon makes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leftoff/cli",
-  "version": "0.9.18-beta.4",
+  "version": "0.9.18-beta.5",
   "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

@@ -5396,3 +5396,40 @@ code .file-ref-off { font-size: inherit; }
 .sub .s-hooks-ring { width: 8px; height: 8px; border-radius: 50%; border: 1.5px dashed currentColor; box-sizing: border-box; flex: none; }
 .fs-head .sub > .s-hooks { height: 22px; vertical-align: middle; }
 .fs-side.is-scrolled .fs-head .sub > .s-hooks { display: none; }
+/* 2026-11-03 which hooks were skipped and why: the same note, its words cut short on a narrow header (the whole in its tip) */
+.sub .s-hooks-skip { max-width: min(420px, 100%); min-width: 0; }
+.sub .s-hooks-skip .s-hooks-t { overflow: hidden; text-overflow: ellipsis; min-width: 0; }
+
+/* 2026-11-03 "Let me answer prompts here" (ui/hook-fix.js): the hooks-skipped note's way out. Centered; a bottom sheet on a phone. */
+.sub .s-hooks-fix { margin-left: 6px; min-height: 44px; padding: 0 10px; border: 1px solid var(--btn-line); border-radius: 8px; background: transparent; color: var(--accent); font: inherit; font-size: 12px; cursor: pointer; white-space: nowrap; }
+@media (pointer: fine) { .sub .s-hooks-fix { min-height: 32px; padding: 0 9px; } }
+.sub .s-hooks-fix:hover { background: var(--btn-hover); }
+.sub .s-hooks-fix:focus-visible { outline: 2px solid var(--accent); outline-offset: 2px; }
+.fs-side.is-scrolled .fs-head .sub > .s-hooks-fix { display: none; }
+.sub .s-hooks-applied .s-hooks-ring { border-style: dotted; }
+.hf-back { position: fixed; inset: 0; z-index: 400; background: rgba(0,0,0,.45); display: flex; align-items: center; justify-content: center; padding: 16px; }
+.hf-modal { width: min(560px, 100%); max-height: calc(100dvh - 32px); overflow: auto; background: var(--card); border: 1px solid var(--line-strong); border-radius: var(--radius); box-shadow: var(--toast-shadow); padding: 16px 18px 14px; color: var(--text2); }
+.hf-grab { display: none; }
+.hf-head { display: flex; align-items: center; justify-content: space-between; gap: 10px; margin-bottom: 6px; }
+.hf-head h2 { margin: 0; font-size: 15px; font-weight: 600; color: var(--text); text-transform: none; letter-spacing: normal; }
+.hf-p { margin: 8px 0; font-size: 13px; line-height: 1.5; }
+.hf-quiet { color: var(--muted); font-size: 12.5px; }
+.hf-file code, .hf-p code { font-size: 12px; overflow-wrap: anywhere; }
+.hf-file { margin: 4px 0; }
+.hf-code { margin: 6px 0; padding: 10px 12px; background: var(--field); border: 1px solid var(--line); border-radius: 8px; font-size: 12px; line-height: 1.45; overflow: auto; white-space: pre; color: var(--text); user-select: all; }
+.hf-mark { display: inline-block; width: 9px; height: 9px; margin-right: 7px; vertical-align: 0; box-sizing: border-box; }
+.hf-mark-ok { border-radius: 50%; background: var(--green); }
+.hf-mark-admin { border-radius: 2px; border: 1.5px solid var(--yellow); transform: rotate(45deg); }
+.hf-mark-off { border-radius: 50%; border: 1.5px dashed var(--muted); }
+.hf-ign { margin-top: 10px; padding-top: 6px; border-top: 1px solid var(--line); }
+.hf-acts { display: flex; justify-content: flex-end; gap: 8px; margin-top: 12px; flex-wrap: wrap; }
+.hf-acts .btn, .hf-x { min-height: 44px; min-width: 44px; justify-content: center; }
+@media (pointer: fine) { .hf-acts .btn, .hf-x { min-height: 32px; min-width: 32px; } }
+.hf-modal .btn:focus-visible { outline: 2px solid var(--accent); outline-offset: 2px; }
+@media (max-width: 640px) {
+  .hf-back { align-items: flex-end; padding: 0; }
+  .hf-modal { width: 100%; max-height: 88dvh; border-radius: var(--radius) var(--radius) 0 0; border-bottom: none; padding: 8px 16px calc(14px + env(safe-area-inset-bottom)); }
+  .hf-grab { display: block; width: 36px; height: 4px; border-radius: 2px; background: var(--line-strong); margin: 2px auto 8px; }
+  .hf-acts { justify-content: stretch; }
+  .hf-acts .btn { flex: 1 1 auto; }
+}

package/ui/app.js

@@ -39,6 +39,7 @@ import { createScrollKeep } from './scroll-keep.js' // 0.9.18 every scroll box k
 import { needsLine, needsItems, needsStrip, needPanel, agentNeedPanel, httpsOnly, agentReplyButton, agentChipHtml, cardBadge, questionAnswer, turnsHtml, dismissedHtml, askDocked, askDockHtml, askSlimHtml, askRows, askBottom } from './needs.js'
 import { SUMMARY_EXAMPLES, LENGTH_CHOICES } from './summary-examples.js'
 import { mdInline, renderSection } from './changelog-md.js'
+import { hooksFixButtonHtml, openHookFix } from './hook-fix.js' // 2026-11-03 "Let me answer prompts here"
 import { crumbHtml, metaLineHtml, detailsHtml, detailsOpen, rememberDetails, branchTileHtml } from './session-head.js' // 0.9.11: the session page's smaller head
 import { projectHref, threadHref, projectPageHtml, askPageHtml, threadHtml as askThreadHtml, recentAsksHtml, fillAsk, pickupState, paletteProjectItems, scopeOfSession, askHref, sessionAskHtml, sessionAskScope, sessionAskToken, scopeHref, pickListHtml, pickFull, PICK_MAX, ARCHIVE_UNDO_MS } from './ask.js' // Ask about a project (roadmap #4)
 import { cardPrsHtml, sessionPrsSection, prsPageHtml, prsBodyHtml, prRowHtml, prRows, readPrFilter, prsHash, prCopyClick } from './prs.js'
@@ -471,7 +472,23 @@ const statusPill = (s) => { if (ownerOffline(s)) return offlinePill(s); const st
 // 2026-11-03 Claude Code's own hook events never came for this session (only the mod's), so its turns
 // are read from the transcript: a quiet note, a dashed ring plus words, the why in the tip
 const HOOKS_QUIET_TIP = 'Claude Code’s hooks aren’t reaching Leftoff for this session, so its prompts and turn ends are read from the transcript instead (a few seconds late). Restarting Claude Code in this folder, or leftoff doctor, usually brings them back.'
-const hooksQuietHtml = (s) => (s && s.hooksQuiet && !s.endedAt ? '<span class="s-hooks" data-tip="' + esc(HOOKS_QUIET_TIP) + '"><span class="s-hooks-ring" aria-hidden="true"></span>hooks not reporting</span>' : '')
+// 2026-11-03 and when Leftoff knows which (Claude Code passed them over: a plugin seated ahead of Leftoff's
+// sends them on past it), the note says which and why; the daemon writes the words (src/hook-skips.js)
+const hooksQuietHtml = (s) => {
+  if (!s || s.endedAt) return ''
+  const k = s.hooksSkipped
+  if (k && k.label) return '<span class="s-hooks s-hooks-skip' + (k.applied ? ' s-hooks-applied' : '') + '" data-tip="' + esc(k.tip || k.label) + '"><span class="s-hooks-ring" aria-hidden="true"></span><span class="s-hooks-t">' + esc(k.label) + '</span></span>' + hooksFixButtonHtml(s, { esc }) // 2026-11-03 applied: "restart Claude Code to apply", no button
+  return s.hooksQuiet ? '<span class="s-hooks" data-tip="' + esc(HOOKS_QUIET_TIP) + '"><span class="s-hooks-ring" aria-hidden="true"></span>hooks not reporting</span>' : ''
+}
+// the note's button: the sheet with the managed-settings lines (ui/hook-fix.js)
+document.addEventListener('click', (e) => {
+  const b = e.target.closest && e.target.closest('[data-hookfix]')
+  if (!b) return
+  e.preventDefault()
+  const sid = b.dataset.hookfix
+  const s = (state.session && state.session.id === sid ? state.session : null) || (state.sessions || []).find((x) => x.id === sid) || { id: sid }
+  openHookFix({ session: s, from: b, api, esc, toast, thisMachine: state.health && state.health.machine })
+})
 const offlinePill = (s) => { const w = offlineLine(s); return '<span class="pill s-offline" data-tip="' + esc(offlineTip(s, w, { was: offlineWas(s) })) + '">' + esc(w) + '</span>' }
 
 const fmtCode = (x) => esc(x).replace(/`([^`]+)`/g, '<code>$1</code>')

package/ui/hook-fix.js

@@ -0,0 +1,109 @@
+// 2026-11-03 "Let me answer prompts here": the hooks-skipped note's way out.
+// Claude Code's Security default runs ahead of the plugins you install (Team or
+// Enterprise, managed settings, a managed MCP file) and sends Stop and
+// permission prompts on past Leftoff. Claude Code ignores appendPlugins in
+// your own ~/.claude/settings.json while it's seated (2.1.317), so the sheet
+// shows the managed-settings lines and where they go, with Copy; Leftoff
+// writes none of it. The one change it can make: take Leftoff's own entry
+// back out of your settings when Claude Code ignores it there (an explicit
+// Remove, this Mac's own browser or a trusted paired device, never on a
+// managed Mac). Another Mac's session: run leftoff doctor --fix there.
+// Centered on a desktop, a bottom sheet on a phone.
+
+export function hooksFixButtonHtml(s, { esc }) {
+  const k = s && s.hooksSkipped
+  if (!k || !k.label || k.applied || s.endedAt) return ''
+  return '<button type="button" class="s-hooks-fix" data-hookfix="' + esc(s.id) + '" data-tip="Why Leftoff can’t answer this session’s prompts from the board, and the settings line that lets it">Let me answer prompts here</button>'
+}
+
+let open = null
+
+export function closeHookFix() {
+  if (!open) return
+  const { back, from, onKey, sid } = open
+  open = null
+  document.removeEventListener('keydown', onKey, true)
+  back.remove()
+  document.documentElement.classList.remove('hf-open')
+  // the header may have been redrawn while the sheet was up: its button for this session now
+  const to = from && from.isConnected ? from : sid ? document.querySelector('[data-hookfix="' + CSS.escape(sid) + '"]') : null
+  if (to) try { to.focus({ preventScroll: true }) } catch {}
+}
+
+const copyText = async (t) => { try { await navigator.clipboard.writeText(t); return true } catch { return false } }
+
+// st: GET /v1/hook-order. -> the sheet's body
+export function hookFixBodyHtml(st, { esc, session = null, thisMachine = null } = {}) {
+  if (session && session.isLocal === false) {
+    const mac = session.machine || 'that Mac'
+    return '<p class="hf-p">This session runs on <b>' + esc(mac) + '</b>, and the settings that decide the plugin order are that Mac’s. Run this there; it says what to add, and why:</p>' +
+      '<div class="hf-code-row"><pre class="hf-code hf-cmd">leftoff doctor --fix</pre></div>' +
+      '<div class="hf-acts"><button type="button" class="btn hf-copy" data-copy="leftoff doctor --fix">Copy</button><button type="button" class="btn primary hf-close">Close</button></div>'
+  }
+  if (!st || st.error) return '<p class="hf-p">Couldn’t read this Mac’s Claude Code settings' + (st && st.error ? ' (' + esc(st.error) + ')' : '') + '. <code>leftoff doctor --fix</code> in a terminal says the same.</p><div class="hf-acts"><button type="button" class="btn primary hf-close">Close</button></div>'
+  let h = ''
+  if (!st.seated) {
+    h += '<p class="hf-p"><span class="hf-mark hf-mark-ok" aria-hidden="true"></span>Nothing here puts a plugin ahead of Leftoff’s hooks' + (thisMachine ? ' on ' + esc(thisMachine) : '') + ' right now. A session that started before a change may still show the note; restart Claude Code there.</p>'
+  } else if (st.placed) {
+    h += '<p class="hf-p"><span class="hf-mark hf-mark-ok" aria-hidden="true"></span><b>Managed settings already seat Leftoff</b> right after Claude Code’s Security default. Restart Claude Code sessions that started before that, and their prompts come here.</p>'
+  } else {
+    h += '<p class="hf-p">' + esc(st.words) + '</p>'
+    h += '<p class="hf-p hf-who"><span class="hf-mark hf-mark-admin" aria-hidden="true"></span>' + (st.managed ? 'Ask whoever manages Claude Code here to ' : 'An admin (on your own Mac, that’s you, with sudo) can ') + (st.snippet.merge ? 'merge this into' : 'put this in') + ':</p>'
+    h += '<div class="hf-file"><code>' + esc(st.snippet.file) + '</code></div>'
+    h += '<pre class="hf-code">' + esc(st.snippet.json) + '</pre>'
+    h += '<p class="hf-p hf-quiet">' + esc(st.snippet.note) + '. Then restart Claude Code. Leftoff never writes managed settings.</p>'
+  }
+  if (st.ignoredEntry) {
+    h += '<div class="hf-ign"><p class="hf-p"><span class="hf-mark hf-mark-off" aria-hidden="true"></span>Your <code>' + esc(st.ignoredEntry.file) + '</code> lists Leftoff in ' + esc(st.ignoredEntry.keys.join(' and ')) + ', which Claude Code ignores here. Removing it changes nothing in Claude Code.</p>' +
+      (st.canUnfix ? '<p class="hf-p hf-quiet">Remove takes out only Leftoff’s entry and keeps a backup in ~/.config/checkpoints/backups.</p>' : '<p class="hf-p hf-quiet">This Mac has managed settings, so Leftoff changes nothing in ~/.claude; delete the entry by hand if you like.</p>') + '</div>'
+  }
+  h += '<div class="hf-acts">' +
+    (st.ignoredEntry && st.canUnfix ? '<button type="button" class="btn hf-unfix">Remove the ignored entry</button>' : '') +
+    (st.seated && !st.placed ? '<button type="button" class="btn hf-copy" data-copy="' + esc(st.snippet.json) + '">Copy</button>' : '') +
+    '<button type="button" class="btn primary hf-close">' + (st.seated && !st.placed ? 'Done' : 'Close') + '</button></div>'
+  return h
+}
+
+export async function openHookFix({ session, from = null, api, esc, toast = () => {}, thisMachine = null } = {}) {
+  closeHookFix()
+  const back = document.createElement('div')
+  back.className = 'hf-back'
+  back.innerHTML = '<div class="hf-modal" role="dialog" aria-modal="true" aria-labelledby="hfTitle"><div class="hf-grab" aria-hidden="true"></div>' +
+    '<div class="hf-head"><h2 id="hfTitle">Let Leftoff answer prompts here</h2><button type="button" class="btn x hf-x" aria-label="Close">✕</button></div>' +
+    '<div class="hf-body"><p class="hf-p hf-quiet">Reading this Mac’s Claude Code settings…</p></div></div>'
+  document.body.appendChild(back)
+  document.documentElement.classList.add('hf-open')
+  const onKey = (e) => {
+    if (e.key === 'Escape') { e.preventDefault(); e.stopPropagation(); closeHookFix(); return }
+    if (e.key === 'Tab') { // keep focus inside
+      const f = [...back.querySelectorAll('button:not([disabled])')]
+      if (!f.length) return
+      const i = f.indexOf(document.activeElement)
+      if (e.shiftKey && i <= 0) { e.preventDefault(); f[f.length - 1].focus() } else if (!e.shiftKey && i === f.length - 1) { e.preventDefault(); f[0].focus() }
+    }
+  }
+  open = { back, from, onKey, sid: session && session.id }
+  document.addEventListener('keydown', onKey, true)
+  const body = back.querySelector('.hf-body')
+  const paint = (st) => {
+    body.innerHTML = hookFixBodyHtml(st, { esc, session, thisMachine })
+    const first = back.querySelector('.hf-copy, .hf-close')
+    if (first) try { first.focus({ preventScroll: true }) } catch {}
+  }
+  back.addEventListener('click', async (e) => {
+    if (e.target === back || e.target.closest('.hf-x, .hf-close')) { closeHookFix(); return }
+    const c = e.target.closest('.hf-copy')
+    if (c) { const ok = await copyText(c.dataset.copy || ''); c.textContent = ok ? 'Copied' : 'Select and copy'; setTimeout(() => { if (c.isConnected) c.textContent = 'Copy' }, 1800); return }
+    const u = e.target.closest('.hf-unfix')
+    if (u) {
+      u.disabled = true; u.textContent = 'Removing…'
+      try {
+        const r = await api('POST', '/v1/hook-order/unfix', { yes: true })
+        paint(r.state)
+        toast(r.wrote ? 'Removed Leftoff’s entry from ' + r.file + (r.backup ? ' (backup kept)' : '') + '. Restart open Claude Code sessions.' : 'Nothing to remove.', 5000)
+      } catch (err) { u.disabled = false; u.textContent = 'Remove the ignored entry'; toast((err && err.message) || 'Couldn’t change it.', 5000) }
+    }
+  })
+  if (session && session.isLocal === false) { paint(null); return }
+  try { paint(await api('GET', '/v1/hook-order?fresh=1')) } catch (err) { paint({ error: (err && err.message) || 'no answer' }) }
+}