@ucsandman/legcli 0.11.0 → 0.13.0

package/src/board/board.js

@@ -33,6 +33,11 @@
     needs_approval: 0, waiting_human: 0, failed: 1, killed: 1, running: 2,
     handing_off: 2, paused: 3, queued: 4, backlog: 5, done: 6,
   }
+  // C.1: liveness decides the surface. A live card is a row in the Background
+  // panel; a finished one collapses into the one ledger line.
+  const LIVE_STATUSES = ['backlog', 'queued', 'running', 'handing_off', 'needs_approval', 'waiting_human', 'paused']
+  const FINISHED_STATUSES = ['done', 'failed', 'killed']
+  const isLive = (card) => LIVE_STATUSES.includes(card.status)
   // 6.5 G10: the button order is fixed and never reflows by availability
   const ACTION_ORDER = ['approve', 'enqueue', 'resume', 'pause', 'handoff_now', 'rerun', 'reassign', 'kill']
   const ACTION_LABELS = {
@@ -58,6 +63,12 @@
   }
   const AGENT_IDS = ['claude', 'codex', 'agy', 'grok']
   const DEFAULT_BIND = '127.0.0.1:4747'
+  // The version these page files shipped with. The server answers /api/health
+  // with the version of the PROCESS, and the two drift apart the moment a
+  // release lands on disk under a board that was started before it: the page
+  // then draws controls the process has no routes for (an empty agent select,
+  // no buckets). test/files-version.test.mjs pins this to package.json.
+  const FILES_VERSION = '0.13.0'
   const TIMELINE_CAP = 12
   // mirrors LOOPBACK in src/auth.mjs; state.bind is "<host>:<port>" and an IPv6
   // host arrives bracketed
@@ -101,6 +112,17 @@
     healthKnown: false,
     bindKnown: false,
     lastHello: null,
+    // C.2: the one-line entry infers its repo from the most recently focused
+    // terminal, published by sessions.js on the leg:sessions window event.
+    sessions: [],
+    // one entry per repo with a live terminal: { repo, repo_name, branch }
+    repoTrunks: [],
+    preferences: null,
+    // { claude: [{id, label, default}], codex: [...], agy: [...], grok: [...] }
+    // from /api/models. null until it answers; an agent missing from it offers
+    // its provider default and nothing else, which is what a bare `leg <agent>`
+    // already does.
+    models: null,
   }
   // a card push while an agent writes its log only moves these two
   const VOLATILE_CARD_FIELDS = ['last_event', 'elapsed_ms']
@@ -216,20 +238,19 @@
   }
 
   // an idle card has no run to measure, and a run whose start did not parse is
-  // not a zero-length run: both print the placeholder rather than a number
-  // A running card counts up from its current run. A card that has finished
-  // still owes the reader the number: created_at to updated_at is what it took,
-  // and `--:--` in that column was three of the five demo stills saying nothing.
-  // Only a card that has never started keeps the placeholder.
+  // not a zero-length run: both print the placeholder rather than a number.
+  // A running card counts up from its current run, in the column the terminal
+  // rows above hold their run clock in. A live card BETWEEN runs has no run
+  // clock at all: created_at to updated_at is the card's whole age, which for
+  // a card that sat in the backlog for a day reads `24:05:00` in a column that
+  // means "this run", so it is labelled for what it is instead: how long it
+  // has been sitting in the state it is in.
   function runElapsed(card) {
     const from = card.active_run ? Date.parse(card.active_run.started_at) : NaN
     if (Number.isFinite(from)) return elapsedClock(Date.now() - from)
     if (!card.runs_count) return '--:--'
-    const started = Date.parse(card.created_at)
-    const ended = Date.parse(card.updated_at)
-    return Number.isFinite(started) && Number.isFinite(ended) && ended >= started
-      ? elapsedClock(ended - started)
-      : '--:--'
+    const since = Date.parse(card.updated_at)
+    return Number.isFinite(since) && since <= Date.now() ? `idle ${agoShort(Date.now() - since)}` : '--:--'
   }
 
   function clockAt(ms) {
@@ -301,6 +322,21 @@
     window.dispatchEvent(new CustomEvent('baton:sessions', { detail }))
   }
 
+  // the entry line's repo inference reads the latest sessions payload without
+  // owning the terminals region: sessions.js still renders it, this file only
+  // keeps a copy for "the most recently focused terminal's repo". Guarded the
+  // same way window.legMessage is above: the pure-logic test harness passes a
+  // window stub with no addEventListener at all.
+  if (typeof window !== 'undefined' && typeof window.addEventListener === 'function') {
+    window.addEventListener('leg:sessions', (e) => {
+      state.sessions = (e.detail && e.detail.sessions) || []
+      // each repo's own default branch, read once per push by the server: the
+      // entry line's `on <branch>` and the trunk it posts come from here
+      state.repoTrunks = (e.detail && e.detail.trunk) || []
+      renderEntryLine()
+    })
+  }
+
   function connectSse() {
     if (state.es) { try { state.es.close() } catch { /* ignore */ } }
     const request = ++state.sseRequest
@@ -395,6 +431,7 @@
       state.isOwner = !(data.you && data.you.role && data.you.role !== 'owner')
       state.healthKnown = true
       renderBoardFacts(data)
+      versionSkew(data.version)
       renderTokenMeta()
       // a guest is told who they are by health, which is open to them
       if (data.you && data.you.role && data.you.role !== 'owner') { guestMode(); return false }
@@ -416,60 +453,15 @@
     }
   }
 
-  // ---- 6.12 step 8: one row per card, no columns ----
-  // Background tasks are the third ledger cell: a count, a line of detail and a
-  // disclosure, the same shape as finished terminals and what landed. Nothing
-  // headless is what the board is for, so the rows live behind the button.
+  // ---- 6.12 step 6: liveness split, cards reborn ----
+  // C.1: a live card is a row in the Background panel, right under Terminals.
+  // A finished one falls into one ledger cell. `cardsOpen` now gates the
+  // finished-cards drawer, not a background-tasks drawer: there is no drawer
+  // for live cards, they are always on the page.
   let cardsOpen = false
   function toggleEmptyState() {
     const empty = document.getElementById('empty-state')
-    const list = document.getElementById('columns')
-    const panel = document.getElementById('cards-drawer')
-    const hasCards = state.cards.size > 0
-    empty.hidden = hasCards
-    list.hidden = !hasCards
-    if (panel) panel.hidden = !(hasCards && cardsOpen)
-  }
-
-  function countCards(...statuses) {
-    let n = 0
-    for (const c of state.cards.values()) if (statuses.includes(c.status)) n += 1
-    return n
-  }
-
-  // G14: a verdict carries its volume
-  function cardsMeta() {
-    const total = state.cards.size
-    if (!total) return ''
-    const running = countCards('running', 'handing_off')
-    const queued = countCards('queued')
-    const backlog = countCards('backlog')
-    const waiting = countCards('waiting_human', 'needs_approval')
-    const finished = countCards('done', 'failed', 'killed')
-    const parts = []
-    if (running) parts.push(`${running} running`)
-    if (queued) parts.push(`${queued} queued`)
-    if (backlog) parts.push(`${backlog} in backlog`)
-    if (waiting) parts.push(`${waiting} waiting on you`)
-    if (finished) parts.push(`${finished} finished`)
-    return parts.length ? parts.join(', ') : `${total} cards, nothing is running`
-  }
-
-  function renderCardsMeta() {
-    const meta = document.querySelector('#board .region-meta')
-    const head = document.getElementById('cards-head')
-    const slot = document.querySelector('#board .ledger-actions')
-    const total = state.cards.size
-    if (meta) meta.textContent = total ? cardsMeta() : 'Nothing is queued. Leg starts the next login only when a terminal hands off.'
-    if (head) head.textContent = total ? `${total} background task${total === 1 ? '' : 's'}` : 'No background tasks'
-    if (!slot) return
-    const existing = document.getElementById('cards-toggle')
-    if (!total) { if (existing) existing.remove(); return }
-    const label = cardsOpen ? `Hide the ${total}` : `View ${total} card${total === 1 ? '' : 's'}`
-    if (existing) { existing.textContent = label; existing.setAttribute('aria-expanded', cardsOpen ? 'true' : 'false'); return }
-    const btn = el('button', { type: 'button', class: 'btn btn-secondary', id: 'cards-toggle', 'aria-expanded': cardsOpen ? 'true' : 'false', 'aria-controls': 'cards-drawer' }, [label])
-    btn.addEventListener('click', () => { cardsOpen = !cardsOpen; toggleEmptyState(); renderCardsMeta() })
-    slot.appendChild(btn)
+    if (empty) empty.hidden = state.cards.size > 0
   }
 
   function rowRank(card) {
@@ -487,11 +479,102 @@
     return [...state.cards.values()].sort((a, b) => rowRank(a) - rowRank(b) || startedAt(a) - startedAt(b))
   }
 
+  function liveCards() { return orderedCards().filter((c) => isLive(c)) }
+
+  // C.5: finished cards, newest first, for the ledger's [View] drawer.
+  function finishedCards() {
+    return [...state.cards.values()]
+      .filter((c) => FINISHED_STATUSES.includes(c.status))
+      .sort((a, b) => (Date.parse(b.updated_at) || 0) - (Date.parse(a.updated_at) || 0))
+  }
+
+  // C.5: "1 running, 1 waiting on you", the same predicate as needsYou on the
+  // terminals region. A zero clause is omitted rather than printed as 0.
+  function backgroundMeta(live) {
+    const running = live.filter((c) => ['running', 'handing_off'].includes(c.status)).length
+    const waiting = live.filter((c) => ['needs_approval', 'waiting_human'].includes(c.status)).length
+    const parts = []
+    if (running) parts.push(`${running} running`)
+    if (waiting) parts.push(`${waiting} waiting on you`)
+    return parts.join(', ')
+  }
+
+  function renderBackgroundRegion(live) {
+    const section = document.getElementById('background')
+    if (section) section.hidden = live.length === 0
+    const meta = document.querySelector('#background .region-meta')
+    if (meta) meta.textContent = backgroundMeta(live)
+  }
+
+  // C.1, C.5: "3 finished cards, 2 done, 1 failed, last 11:02 PM", one line,
+  // never a count of the live cards (they are their own region now).
+  function renderFinishedLedger() {
+    const finished = finishedCards()
+    const head = document.getElementById('cards-head')
+    const meta = document.querySelector('#board .region-meta')
+    if (head) {
+      if (!finished.length) head.textContent = 'No finished cards'
+      else {
+        const done = finished.filter((c) => c.status === 'done').length
+        const failed = finished.filter((c) => c.status === 'failed').length
+        const killed = finished.filter((c) => c.status === 'killed').length
+        const parts = []
+        if (done) parts.push(`${done} done`)
+        if (failed) parts.push(`${failed} failed`)
+        if (killed) parts.push(`${killed} killed`)
+        head.textContent = `${plural(finished.length, 'finished card')}, ${parts.join(', ')}, last ${clock(finished[0].updated_at)}`
+      }
+    }
+    if (meta) meta.textContent = ''
+    const slot = document.querySelector('#board .ledger-actions')
+    if (slot) {
+      let view = document.getElementById('cards-view-toggle')
+      if (!finished.length) { if (view) view.remove() } else {
+        if (!view) {
+          view = el('button', { type: 'button', class: 'btn btn-secondary', id: 'cards-view-toggle', 'aria-controls': 'cards-drawer' }, ['View'])
+          view.addEventListener('click', () => { cardsOpen = !cardsOpen; renderFinishedLedger() })
+          slot.appendChild(view)
+        }
+        view.textContent = cardsOpen ? 'Hide' : 'View'
+        view.setAttribute('aria-expanded', cardsOpen ? 'true' : 'false')
+      }
+    }
+    const panel = document.getElementById('cards-drawer')
+    if (panel) panel.hidden = !(cardsOpen && finished.length)
+    renderFinishedList(finished)
+  }
+
+  // C.5: each drawer row is one line, never the full interactive row a live
+  // card gets: "done after 3 runs, landed 7f3a2c1" or "failed at station
+  // build after 2 runs: <last event summary>".
+  function finishedLine(card) {
+    const runs = plural(card.runs_count || 0, 'run')
+    const last = card.last_event ? card.last_event.summary : 'no events yet'
+    if (card.status === 'done') {
+      const landed = card.land && card.land.state === 'landed' && card.land.sha ? `landed ${String(card.land.sha).slice(0, 7)}` : last
+      return `done after ${runs}, ${landed}`
+    }
+    if (card.status === 'failed') return `failed at station ${card.station} after ${runs}: ${last}`
+    return `killed after ${runs}`
+  }
+
+  function renderFinishedList(finished) {
+    const list = document.getElementById('columns')
+    if (!list) return
+    list.textContent = ''
+    for (const card of finished) {
+      list.appendChild(el('div', { class: 'finished-line' }, [
+        el('span', { class: 'row-meta mono' }, [card.title || card.card_id]),
+        el('span', { class: 'finished-names' }, [finishedLine(card)]),
+      ]))
+    }
+  }
+
   // Re-appending every row costs one DOM move each and can move a node out from
   // under the cursor, so it happens only when the order string actually changed.
   function orderRows() {
-    const list = document.getElementById('columns')
-    const order = orderedCards().map((c) => c.card_id)
+    const list = document.getElementById('background-grid')
+    const order = liveCards().map((c) => c.card_id)
     const key = order.join(',')
     if (key === state.rowOrder) return
     state.rowOrder = key
@@ -502,19 +585,29 @@
     if (state.drawerId) placeDetail(state.drawerId)
   }
 
+  // called after anything that can change which cards are live, finished, or
+  // how many of each: cheap text/count work, safe to run in full every time.
+  function refreshCardMeta() {
+    const live = liveCards()
+    renderBackgroundRegion(live)
+    renderFinishedLedger()
+    placeEntryLine(live.length > 0)
+    renderEntryLine()
+    toggleEmptyState()
+  }
+
   function renderBoard() {
-    const list = document.getElementById('columns')
+    const grid = document.getElementById('background-grid')
     // the detail region is a child of this list while a row is expanded: park it
     // back on the body so the wipe below does not take it out of the document
     document.body.appendChild(document.getElementById('drawer'))
-    list.textContent = ''
+    if (grid) grid.textContent = ''
     state.cardNodes = new Map()
-    const order = orderedCards()
-    for (const card of order) renderRow(card)
-    state.rowOrder = order.map((c) => c.card_id).join(',')
+    const live = liveCards()
+    for (const card of live) renderRow(card)
+    state.rowOrder = live.map((c) => c.card_id).join(',')
     if (state.drawerId) placeDetail(state.drawerId)
-    renderCardsMeta()
-    toggleEmptyState()
+    refreshCardMeta()
   }
 
   // the board is pushed a card for every write under its directory, log bytes
@@ -541,14 +634,22 @@
     return cache.expanded ? 200 : 8
   }
 
+  // a card that fell off liveness (running -> done, say) loses its row; the
+  // finished ledger picks it up on the next refreshCardMeta() instead
+  function removeLiveRow(id) {
+    const root = state.cardNodes.get(id)
+    if (root) { root.remove(); state.cardNodes.delete(id) }
+    state.rowOrder = ''
+    if (state.drawerId === id) closeDrawer()
+  }
+
   function upsertCard(card) {
     state.boardRevision += 1
     const prev = state.cards.get(card.card_id)
     const tail = staleLogTail(state.logState.get(card.card_id), card, Date.now())
-    renderRow(card)
-    orderRows()
-    renderCardsMeta()
-    toggleEmptyState()
+    state.cards.set(card.card_id, card)
+    if (isLive(card)) { renderRow(card); orderRows() } else { removeLiveRow(card.card_id) }
+    refreshCardMeta()
     if (tail) ensureLogLoaded(card.card_id, tail)
     if (state.drawerId === card.card_id && drawerRefreshNeeded(prev, card)) scheduleDrawerRefresh()
   }
@@ -557,12 +658,8 @@
     state.boardRevision += 1
     state.cards.delete(id)
     state.logState.delete(id)
-    const root = state.cardNodes.get(id)
-    if (root) { root.remove(); state.cardNodes.delete(id) }
-    state.rowOrder = ''
-    renderCardsMeta()
-    toggleEmptyState()
-    if (state.drawerId === id) closeDrawer()
+    removeLiveRow(id)
+    refreshCardMeta()
   }
 
   function onLedgerEvent(ev) {
@@ -618,16 +715,14 @@
       return { tone: 'warn', text: `waiting on you at station ${card.station} since ${clock(card.updated_at)}` }
     }
     if (card.status === 'done') return { tone: 'ok', text: `done after ${plural(card.runs_count || 0, 'run')}, ${last ? last.summary : 'no events yet'}` }
+    // C.3: a card runs -p --output-format json, mute until the leg exits. Once
+    // it has said anything real the generic branch below still carries it.
+    if (card.status === 'running' && last && (last.type === 'leg_started' || last.summary === 'leg started')) {
+      return { tone: 'muted', text: `no message until this leg ends, started ${clock(last.ts)}` }
+    }
     return { tone: 'muted', text: `${formatLastEvent(last)}${last ? `, ${clock(last.ts)}` : ''}` }
   }
 
-  function shortWorktree(card) {
-    if (!card.worktree) return ''
-    const parts = String(card.worktree).split(/[\\/]/).filter(Boolean)
-    let i = parts.lastIndexOf('.leg-worktrees'); if (i === -1) i = parts.lastIndexOf('.baton-worktrees');
-    return i > 0 ? parts.slice(i - 1).join('/') : parts.slice(-2).join('/')
-  }
-
   // 6.11: flat inline tokens, middot-separated by CSS, each agent name printed
   // beside its own colour so identity never rides on hue alone.
   function buildChainRail(card) {
@@ -690,11 +785,17 @@
     row.cancelBtn.focus()
   }
 
-  function buildActions(card) {
-    const wrap = el('div', { class: 'row-actions' })
+  // C.3: at most four buttons in the row's 2x2 grid, fixed order; anything
+  // left over moves into the expansion instead of a fifth slot.
+  function splitActions(card) {
     const available = card.actions || []
-    for (const action of ACTION_ORDER) {
-      if (!available.includes(action) || !ACTION_LABELS[action]) continue
+    const ordered = ACTION_ORDER.filter((a) => available.includes(a) && ACTION_LABELS[a])
+    return { shown: ordered.slice(0, 4), overflow: ordered.slice(4) }
+  }
+
+  function buildActions(card, actions) {
+    const wrap = el('div', { class: 'row-actions' })
+    for (const action of actions) {
       const label = ACTION_LABELS[action]
       const cls = `btn ${ACTION_CLASS[action] || 'btn-secondary'}`
       const run = action === 'reassign' ? () => openReassign(card, wrap) : () => runAction(card, action)
@@ -706,6 +807,82 @@
     return wrap
   }
 
+  // C.3: a short relative age ("6m ago"), for the work stat line only. The
+  // pinned time grammar in sessions.js (elapsedClock/clockAt) is unrelated:
+  // this is a duration since a timestamp, not an elapsed-run clock.
+  function agoShort(ms) {
+    const s = Math.max(0, Math.floor(ms / 1000))
+    if (s < 60) return `${s}s`
+    const m = Math.floor(s / 60)
+    if (m < 60) return `${m}m`
+    const h = Math.floor(m / 60)
+    if (h < 48) return `${h}h`
+    return `${Math.floor(h / 24)}d`
+  }
+
+  function agoSince(ts) {
+    const at = ts ? Date.parse(ts) : NaN
+    return Number.isFinite(at) ? agoShort(Date.now() - at) : 'an unknown time'
+  }
+
+  // C.3: the branch a live card works on is leg/<card_id> once it has a
+  // worktree (src/worktree.mjs branchName), else it has not started and the
+  // register falls back to the trunk it will branch from.
+  // A terminal's short id is the random tail of its session id. A card id has
+  // no hash on the end, only a slug, and `card-20260917-2300-seeded-live-card-3`
+  // ends in `3`: a bare digit identifies nothing on a board with four cards. So
+  // the short id is the last segment, grown leftwards until it is a token a
+  // reader can match back to the row (4 characters or more).
+  function cardShortId(id) {
+    const parts = String(id || '').split('-').filter(Boolean)
+    if (!parts.length) return ''
+    let out = parts[parts.length - 1]
+    for (let i = parts.length - 2; i >= 0 && out.length < 4; i--) out = `${parts[i]}-${out}`
+    return out
+  }
+
+  // The branch this card's checkout is really on, for a reader who is going to
+  // paste it into `git checkout`. A card that cut its own worktree is on
+  // `leg/<card-id>`; one that adopted a terminal's is on that TERMINAL's
+  // branch, which no reader can derive from the card id, so the server records
+  // it with the worktree (`worktree_branch`). Shortened for the row only when
+  // the full name does not fit, and the full name is on the element's title.
+  function cardBranch(card) {
+    if (card.worktree_branch) return card.worktree_branch
+    if (card.worktree) return `leg/${card.card_id}`
+    return card.trunk || 'main'
+  }
+
+  function cardAgent(card) { return (card.agent_model && card.agent_model.agent) || card.active_adapter || null }
+
+  function cardAgentModelText(card) {
+    const agent = cardAgent(card)
+    if (!agent) return null
+    const model = card.agent_model && card.agent_model.model
+    return model ? `${agent}/${model}` : agent
+  }
+
+  // C.3: "4 files, +212 -18, tests green 6m ago", built only from the parts
+  // the server actually measured. Nothing measured prints nothing.
+  function workStatLine(card) {
+    const parts = []
+    const w = card.work
+    if (w) {
+      if (Number.isFinite(w.files)) parts.push(plural(w.files, 'file'))
+      const ins = Number.isFinite(w.insertions) ? `+${w.insertions}` : ''
+      const del = Number.isFinite(w.deletions) ? `-${w.deletions}` : ''
+      const diff = [ins, del].filter(Boolean).join(' ')
+      if (diff) parts.push(diff)
+    }
+    if (card.tests) parts.push(`tests ${card.tests.state} ${agoSince(card.tests.at)} ago`)
+    if (card.land) {
+      if (card.land.state === 'bounced') parts.push(`land bounced: ${card.land.reason || 'unknown reason'}`)
+      else if (card.land.state === 'landed' && card.land.sha) parts.push(`landed ${String(card.land.sha).slice(0, 7)}`)
+      else if (card.land.state === 'failed') parts.push(`land failed${card.land.reason ? `: ${card.land.reason}` : ''}`)
+    }
+    return parts.join(', ')
+  }
+
   // the reassign picker replaces the buttons in place, like the confirm row
   async function openReassign(card, wrap) {
     if (!state.adapters) {
@@ -734,33 +911,37 @@
     wrap.appendChild(el('div', { class: 'reassign-picker' }, [adapterSelect, modeSelect, apply, cancel]))
   }
 
-  // 5.1: R1 who, R2 what, R3 where, R4 when-act-verdict. No object type moves a
-  // field to a different x, which is why a card row reads down the same four
-  // columns as an account and a terminal.
+  // C.3: R1 register (state, station, repo/branch, agent/model), R2 title +
+  // sentence, R3 the work stat line (only what is measured), R4 elapsed, the
+  // short id, and at most four action buttons. A card row reads down the same
+  // four columns as a terminal (.row already carries that shape, see
+  // board.css's own comment on it: "the same shape as .term-row").
   function buildRow(card) {
     const said = cardSentence(card)
-    const chain = (card.chain_view && card.chain_view.length ? card.chain_view : card.chain) || []
-    const agent = card.active_adapter || (chain[0] ? chain[0].adapter : null)
+    const agentText = cardAgentModelText(card)
+    const agentBase = cardAgent(card)
     const title = el('button', {
       type: 'button', class: 'row-title', 'aria-expanded': state.drawerId === card.card_id ? 'true' : 'false',
       onclick: () => expandRow(card.card_id),
     }, [card.title || truncate(card.task, 60) || card.card_id])
     const sentence = el('p', { class: `sentence tone-${said.tone}` }, [said.text])
     const elapsed = el('span', { class: 'elapsed' }, [runElapsed(card)])
+    const statLine = workStatLine(card)
+    const { shown } = splitActions(card)
     const cells = [
       el('div', { class: 'r1' }, [
-        el('span', { class: agent ? `chip chip-id-${agentClass(agent)}` : 'chip' }, [agent || 'no agent']),
-        card.station && card.station !== '-' ? el('span', { class: 'chip' }, [card.station]) : null,
         statusWord(card),
+        card.station && card.station !== '-' ? el('span', { class: 'chip' }, [card.station]) : null,
+        el('span', { class: 'row-meta mono', title: `${card.repo_name || 'no repo'} on ${cardBranch(card)}` }, [`${card.repo_name || 'no repo'} on ${truncate(cardBranch(card), 32)}`]),
+        agentText ? el('span', { class: `chip chip-id-${agentClass(agentBase)}` }, [agentText]) : null,
       ]),
       el('div', { class: 'r2' }, [title, sentence]),
-      el('div', { class: 'r3' }, [
-        el('p', { class: 'row-meta mono' }, [`${card.repo_name || 'no repo'}@${card.trunk || 'main'}`]),
-        card.worktree ? el('p', { class: 'row-meta mono', title: card.worktree }, [shortWorktree(card)]) : null,
-        buildChainRail(card),
-        buildLeases(card),
+      el('div', { class: 'r3' }, statLine ? [el('p', { class: 'row-meta' }, [statLine])] : []),
+      el('div', { class: 'r4' }, [
+        elapsed,
+        el('span', { class: 'row-meta mono', title: card.card_id }, [cardShortId(card.card_id)]),
+        buildActions(card, shown),
       ]),
-      el('div', { class: 'r4' }, [elapsed, buildActions(card)]),
     ]
     return { cells, slots: { title, sentence, elapsed } }
   }
@@ -771,7 +952,7 @@
     if (!root) {
       root = el('article', { class: 'row', 'data-card-id': card.card_id })
       state.cardNodes.set(card.card_id, root)
-      document.getElementById('columns').appendChild(root)
+      document.getElementById('background-grid').appendChild(root)
       state.rowOrder = ''
     } else {
       while (root.firstChild) root.removeChild(root.firstChild)
@@ -854,6 +1035,27 @@
     return [el('div', { class: 'kv' }, rows), copy]
   }
 
+  // C.4: card -> terminal. Take over pauses the card and hands back one
+  // copyable command; a terminal cannot be opened from a browser tab, so the
+  // board says that plainly rather than pretending it can.
+  function buildTakeOver(card) {
+    const box = el('div', { class: 'kv' })
+    const btn = el('button', { type: 'button', class: 'btn btn-secondary', onclick: async () => {
+      try {
+        const data = await api(`/api/cards/${encodeURIComponent(card.card_id)}/take-over`, { method: 'POST', body: {} })
+        box.textContent = ''
+        box.appendChild(el('p', { class: 'sentence tone-muted' }, ['A terminal cannot be opened from a browser tab, so this is the one command Leg hands you.']))
+        const row = el('div', { class: 'reassign-picker' }, [
+          el('span', { class: 'row-meta mono' }, [data.command]),
+          el('button', { type: 'button', class: 'btn btn-secondary', onclick: () => copyToClipboard(data.command) }, ['Copy']),
+        ])
+        box.appendChild(row)
+      } catch (err) { toast(err.message) }
+    } }, ['Take over'])
+    box.appendChild(btn)
+    return detailSection('Take over', 'pauses the card and starts an interactive terminal from its bundle', box)
+  }
+
   function eventRow(e) {
     return el('div', { class: 'turn' }, [
       el('span', { class: 'turn-when' }, [clock(e.ts)]),
@@ -901,6 +1103,17 @@
     for (const st of stations) pipeline.push(...kvRow(st.name, `${st.kind}${st.name === card.station ? ', this station' : ''}`))
     content.appendChild(detailSection('Pipeline', at ? `station ${at} of ${stations.length}` : `${plural(stations.length, 'station')}, none started`, el('div', { class: 'kv' }, pipeline)))
 
+    // C.3: the chain rail, the leases and the pipeline above all moved out of
+    // the row and into this expansion; the row itself carries only the model
+    // token and the station name now.
+    content.appendChild(detailSection('Chain', null, buildChainRail(card)))
+    content.appendChild(detailSection('Leases', null, buildLeases(card)))
+
+    const { overflow } = splitActions(card)
+    if (overflow.length) content.appendChild(detailSection('More actions', 'past the four on the row', buildActions(card, overflow)))
+
+    content.appendChild(buildTakeOver(card))
+
     const runs = detail.runs || []
     const runRows = []
     for (const r of runs) runRows.push(...kvRow(`run ${r.run}`, `${r.adapter}, ${r.outcome ?? r.status}, signal ${r.signal ?? 'none'}, exit ${r.exit_code ?? 'none'}`))
@@ -1012,22 +1225,71 @@
     if (root && root.slots) root.slots.title.focus()
   }
 
+  // ---- 6.15 step 6: the one-line background entry (C.2) ----
+  // src/board/entry.js OWNS THE ROW. It is on this page and on /floor, and one
+  // sentence that starts work has to post one body from both, so the row lives
+  // in a file both pages load and this file keeps only the names its own code
+  // and its test seams call. `state` is handed over live: the row reads
+  // sessions, cards, preferences, adapters and models on every render, never a
+  // copy taken at mount.
+  const entryUi = window.legEntry.create({
+    el,
+    api,
+    toast,
+    host: state,
+    boxId: 'card-entry',
+    isGuest,
+    onCreated: (card) => upsertCard(card),
+    // this page has the dialog markup, so More settings opens it in place
+    onMoreSettings: () => openNewCardDialog(),
+    // C.2: the row sits under the Background panel, and under Terminals when
+    // there are no live cards to sit under
+    moveUnder: { whenLive: 'background', whenEmpty: '.region-terminals' },
+  })
+  const entryState = entryUi.entryState
+  const knownRepos = () => entryUi.knownRepos()
+  const entryRepo = () => entryUi.entryRepo()
+  const realAdapters = () => entryUi.realAdapters()
+  const ladderAgents = () => entryUi.ladderAgents()
+  const asRung = (agent, model) => entryUi.asRung(agent, model)
+  const ladderLabel = (r) => entryUi.ladderLabel(r)
+  const modelSelect = (agent, model, label, onPick) => entryUi.modelSelect(agent, model, label, onPick)
+  const entryChain = () => entryUi.entryChain()
+  const entryTrunk = (repo) => entryUi.entryTrunk(repo)
+  const renderEntryLine = () => entryUi.renderEntryLine()
+  const placeEntryLine = (hasLive) => entryUi.placeEntryLine(hasLive)
+
+  // sessions.js draws the ladder editor in Settings and needs the same model
+  // catalog, but the two files share no module scope (both are plain scripts
+  // served to the browser), so the one fetch is published here and read there.
+  // Narrow on purpose: the catalog and nothing else of this file's state.
+  function publishModels() {
+    if (typeof window === 'undefined') return
+    window.legBoard = { models: state.models }
+  }
+
   // ---- new card dialog ----
+  // Two questions, side by side: WHAT the work is (task, repo, branch) and WHO
+  // runs it. "Who runs it" is the same ladder the one-line entry row walks,
+  // one row per rung and a model select on each, prefilled from preferences so
+  // the dialog opens showing exactly what pressing Start on that row would
+  // have done. Every other field the dialog ever had is under Advanced, and
+  // every one of them still posts.
   function newCardDialogEls() {
     return {
       dialog: document.getElementById('new-card-dialog'),
       form: document.getElementById('new-card-form'),
       error: document.getElementById('new-card-error'),
       repo: document.getElementById('nc-repo'),
+      repoKnown: document.getElementById('nc-repo-known'),
       task: document.getElementById('nc-task'),
-      firstAgent: document.getElementById('nc-first-agent'),
-      firstControls: document.getElementById('nc-first-controls'),
       testAdapter: document.getElementById('nc-test-adapter'),
       fallbackSummary: document.getElementById('nc-fallback-summary'),
       pipeline: document.getElementById('nc-pipeline'),
       customPipeline: document.getElementById('nc-custom-pipeline'),
       chainRows: document.getElementById('nc-chain-rows'),
       addRowBtn: document.getElementById('nc-add-row'),
+      saveLadder: document.getElementById('nc-save-ladder'),
       leases: document.getElementById('nc-leases'),
       trunk: document.getElementById('nc-trunk'),
       landMode: document.getElementById('nc-land-mode'),
@@ -1040,139 +1302,266 @@
 
   function adapterLabel(adapter) { return adapter.fake ? `${adapter.name} (test/demo)` : adapter.name }
 
-  // the agents already named in this dialog: the first agent and every fallback
-  // row already added. A fallback set to one of these can never fire.
-  function chosenAdapters(ui) {
-    const used = [ui.testAdapter.value || ui.firstAgent.value]
-    for (const row of ui.chainRows.children) if (row.fields) used.push(row.fields.adapterSelect.value)
-    return used.filter(Boolean)
-  }
-
-  function addChainRow(ui, { adapter: preferred = null, first = false } = {}) {
-    const adapterSelect = el('select', { 'aria-label': 'Chain adapter' })
-    const adapters = [...(state.adapters || [])].sort((a, b) => Number(a.fake) - Number(b.fake))
-    for (const a of adapters) adapterSelect.appendChild(el('option', { value: a.name }, [adapterLabel(a)]))
-    // Add fallback agent used to default to the first option in the list, which
-    // is normally the agent already chosen as First agent: the summary line then
-    // read "Leg tries claude, then agy, then claude", a fallback that cannot
-    // fire. rebuildDefaultFallbacks already applies this filter.
-    if (!preferred && !first) {
-      const used = chosenAdapters(ui)
-      preferred = adapters.filter((a) => !a.fake).map((a) => a.name).find((name) => !used.includes(name)) || null
-    }
-    if (preferred && adapters.some((a) => a.name === preferred)) adapterSelect.value = preferred
-    const modeSelect = el('select', { 'aria-label': 'Chain mode' })
-    const approveCheckbox = el('input', { type: 'checkbox', 'aria-label': 'Approve before this leg' })
-    const approveLabel = el('label', {}, [approveCheckbox, ' approval before start'])
-    const turnsInput = el('input', { type: 'number', min: '0', 'aria-label': 'Max turns', placeholder: 'max turns' })
-    const fakeInput = el('input', { type: 'text', 'aria-label': 'Scripted test behavior', placeholder: 'test behavior' })
-    const removeBtn = first ? null : el('button', { type: 'button', class: 'btn btn-danger', 'aria-label': 'Remove fallback agent' }, ['Remove'])
-    const title = el('span', { class: 'fallback-row-title' }, [first ? `First: ${preferred}` : `Fallback ${ui.chainRows.children.length + 1}`])
-    const row = el('div', { class: `chain-row${first ? '' : ' fallback-row'}` }, [title, adapterSelect, modeSelect, approveLabel, turnsInput, fakeInput, removeBtn])
-    if (first) adapterSelect.hidden = true
-    if (removeBtn) removeBtn.addEventListener('click', () => { row.remove(); refreshFallbackSummary(ui) })
+  // The rows as DATA. The DOM used to be the record: a row's values were read
+  // back off its own inputs, which works until rows can move, because moving a
+  // row means rebuilding it and a rebuilt input is empty. Reorder, remove and
+  // renumber are all list operations here, and the DOM is redrawn from the list.
+  let ncRows = []
 
-    function populateModes() {
-      modeSelect.textContent = ''
-      const adapter = (state.adapters || []).find((a) => a.name === adapterSelect.value)
-      const allowed = adapter ? adapter.modes.allowed : []
-      for (const m of allowed) modeSelect.appendChild(el('option', { value: m }, [MODE_LABELS[m] ? `${MODE_LABELS[m]} (${m})` : m]))
-      if (adapter && adapter.modes.default) modeSelect.value = adapter.modes.default
-      fakeInput.hidden = !(adapter && adapter.fake)
-    }
-    adapterSelect.addEventListener('change', populateModes)
-    // the summary sentence names the fallback agents by row, so it has to
-    // follow a row whose agent the reader changed after it was added
-    if (!first) adapterSelect.addEventListener('change', () => refreshFallbackSummary(ui))
-    populateModes()
+  function ncAdapter(name) { return (state.adapters || []).find((a) => a.name === name) || null }
 
-    row.fields = { adapterSelect, modeSelect, approveCheckbox, turnsInput, fakeInput }
-    ;(first ? ui.firstControls : ui.chainRows).appendChild(row)
-    refreshFallbackSummary(ui)
-    return row
+  function ncRow(agent, model) {
+    const adapter = ncAdapter(agent)
+    return {
+      agent: adapter ? adapter.name : agent,
+      model: model || '',
+      mode: adapter && adapter.modes ? (adapter.modes.default || '') : '',
+      approve: false, turns: '', fake: '',
+    }
   }
 
-  function refreshFallbackSummary(ui) {
-    const names = [...ui.chainRows.children].filter((row) => row.fields).map((row) => row.fields.adapterSelect.value)
-    ui.fallbackSummary.textContent = names.length
-      ? `If the first agent cannot continue, Leg tries ${names.join(', then ')} in this order.`
-      : 'No fallback agent is set. Add one under Advanced options if another agent should take over.'
+  // the first installed agent no row already names: a fallback that repeats the
+  // row above it can never fire
+  function ncNextAgent() {
+    const used = ncRows.map((r) => r.agent)
+    const real = realAdapters()
+    return real.find((a) => !used.includes(a)) || real[0] || ((state.adapters || [])[0] || {}).name || 'claude'
   }
 
-  function rebuildFirstControls(ui) {
-    ui.firstControls.textContent = ''
-    addChainRow(ui, { adapter: ui.testAdapter.value || ui.firstAgent.value, first: true })
-  }
+  const ncLeg = (r) => (r.model ? `${r.agent}/${r.model}` : r.agent)
 
-  function rebuildDefaultFallbacks(ui) {
+  function refreshFallbackSummary(ui) {
+    const legs = ncRows.map(ncLeg)
+    ui.fallbackSummary.textContent = legs.length > 1
+      ? `Leg starts on ${legs[0]}, and tries ${legs.slice(1).join(', then ')} only when the row before it cannot continue.`
+      : legs.length === 1
+        ? `Leg runs ${legs[0]} and stops there. Add a fallback to hand the work on when it cannot continue.`
+        : 'No agent is set. Add a row, or this card has nothing to run it.'
+  }
+
+  // `focusKey` is the control the reader should still be on after the redraw.
+  // Every row is destroyed and rebuilt here, so the button a keyboard user just
+  // pressed Enter on is gone and focus falls to <body>: pressing Up twice meant
+  // tabbing back through every control above it. Same idea as sessions.js's
+  // takeFocus/putFocus pair (data-focus-key), but the intent is passed in rather
+  // than read off document.activeElement, because the moved row's key is known
+  // at the press and the row it lands on is a different index.
+  function renderChainRows(ui, focusKey) {
     ui.chainRows.textContent = ''
-    const first = ui.firstAgent.value
-    const real = (state.adapters || []).filter((a) => !a.fake).map((a) => a.name)
-    const preferred = AGENT_IDS.filter((name) => real.includes(name) && name !== first)
-    for (const adapter of preferred) addChainRow(ui, { adapter })
+    const keyed = new Map()
+    ncRows.forEach((row, index) => {
+      // every control on the row is named for the step it belongs to, so a
+      // screen reader hears "Model for fallback 2" and not "Chain adapter"
+      const step = index === 0 ? 'the first agent' : `fallback ${index}`
+      const adapter = ncAdapter(row.agent)
+      const box = el('div', { class: 'chain-row' })
+      box.appendChild(el('span', { class: 'chain-num' }, [`${index + 1}.`]))
+
+      const who = el('select', { 'aria-label': `Provider for ${step}` })
+      for (const a of [...(state.adapters || [])].sort((x, y) => Number(x.fake) - Number(y.fake))) who.appendChild(el('option', { value: a.name }, [adapterLabel(a)]))
+      who.value = row.agent
+      who.addEventListener('change', () => {
+        row.agent = who.value
+        // a model belongs to one provider: carrying gpt-5.6-luna over to claude
+        // would post a model that CLI has never heard of
+        row.model = ''
+        const next = ncAdapter(row.agent)
+        row.mode = next && next.modes ? (next.modes.default || '') : ''
+        renderChainRows(ui)
+      })
+      box.appendChild(who)
+
+      box.appendChild(modelSelect(row.agent, row.model, `Model for ${step}`, (v) => { row.model = v; refreshFallbackSummary(ui) }))
+
+      const mode = el('select', { 'aria-label': `Permissions for ${step}` })
+      for (const m of (adapter && adapter.modes ? adapter.modes.allowed : [])) mode.appendChild(el('option', { value: m }, [MODE_LABELS[m] ? `${MODE_LABELS[m]} (${m})` : m]))
+      mode.value = row.mode || (adapter && adapter.modes ? adapter.modes.default : '')
+      mode.addEventListener('change', () => { row.mode = mode.value })
+      box.appendChild(mode)
+
+      const approve = el('input', { type: 'checkbox', 'aria-label': `Ask before ${step} starts` })
+      approve.checked = row.approve
+      approve.addEventListener('change', () => { row.approve = approve.checked })
+      box.appendChild(el('label', { class: 'chain-toggle' }, [approve, ' ask before start']))
+
+      const turns = el('input', { type: 'number', min: '1', class: 'chain-turns', 'aria-label': `Max turns for ${step}`, placeholder: 'max turns', value: row.turns })
+      turns.addEventListener('input', () => { row.turns = turns.value })
+      box.appendChild(turns)
+
+      if (adapter && adapter.fake) {
+        const fake = el('input', { type: 'text', class: 'chain-fake', 'aria-label': `Scripted behaviour for ${step}`, placeholder: 'test behavior', value: row.fake })
+        fake.addEventListener('input', () => { row.fake = fake.value })
+        box.appendChild(fake)
+      }
+
+      const up = el('button', { type: 'button', class: 'btn btn-secondary', 'aria-label': `Move ${step} earlier`, 'data-focus-key': `chain:${index}:up`, disabled: index === 0 ? '' : null }, ['Up'])
+      const down = el('button', { type: 'button', class: 'btn btn-secondary', 'aria-label': `Move ${step} later`, 'data-focus-key': `chain:${index}:down`, disabled: index === ncRows.length - 1 ? '' : null }, ['Down'])
+      const drop = el('button', { type: 'button', class: 'btn btn-danger', 'aria-label': `Remove ${step}`, 'data-focus-key': `chain:${index}:remove`, disabled: ncRows.length < 2 ? '' : null }, ['Remove'])
+      // the key names where the row LANDS, not where it was pressed
+      up.addEventListener('click', () => { ncRows.splice(index - 1, 0, ncRows.splice(index, 1)[0]); renderChainRows(ui, `chain:${index - 1}:up`) })
+      down.addEventListener('click', () => { ncRows.splice(index + 1, 0, ncRows.splice(index, 1)[0]); renderChainRows(ui, `chain:${index + 1}:down`) })
+      drop.addEventListener('click', () => { ncRows.splice(index, 1); renderChainRows(ui, `chain:${Math.min(index, ncRows.length - 1)}:remove`) })
+      box.append(up, down, drop)
+      keyed.set(`chain:${index}:up`, up)
+      keyed.set(`chain:${index}:down`, down)
+      keyed.set(`chain:${index}:remove`, drop)
+
+      ui.chainRows.appendChild(box)
+    })
     refreshFallbackSummary(ui)
+    if (focusKey) restoreChainFocus(ui, keyed, focusKey)
+  }
+
+  // A row moved to either end loses the button that moved it, and the last row
+  // standing cannot be removed, so the focus goes to the nearest live control on
+  // that row and, when the row itself is gone, to Add a fallback.
+  function restoreChainFocus(ui, keyed, focusKey) {
+    const at = focusKey.split(':')[1]
+    let target = keyed.get(focusKey) || null
+    if (!target || target.disabled) {
+      target = [`chain:${at}:up`, `chain:${at}:down`, `chain:${at}:remove`]
+        .map((k) => keyed.get(k))
+        .find((node) => node && !node.disabled) || ui.addRowBtn || null
+    }
+    if (target && typeof target.focus === 'function') target.focus({ preventScroll: true })
+  }
+
+  // "Save as my default ladder": the rows become preferences.handoff_ladder,
+  // which the entry row and every new terminal read. A scripted test adapter is
+  // never a rung and the server refuses one, so it is dropped here with a
+  // sentence rather than sent and refused; two rows naming the same agent and
+  // model are one rung, for the same reason.
+  async function saveLadderFromRows(rows) {
+    const real = realAdapters()
+    // and of those, the agents a SAVED ladder may name. A custom adapter added
+    // with `leg adapter add` is a real agent and runs a card, but preferences
+    // takes a closed list and refuses the whole array over one rung it does not
+    // know, so the claude rung beside a custom one was never written either.
+    const saveable = ladderAgents()
+    const dropped = []
+    const seen = new Set()
+    const ladder = []
+    for (const r of rows) {
+      if (!real.includes(r.agent)) continue
+      if (!saveable.includes(r.agent)) { if (!dropped.includes(r.agent)) dropped.push(r.agent); continue }
+      const key = `${r.agent}/${r.model || ''}`
+      if (seen.has(key)) continue
+      seen.add(key)
+      ladder.push(asRung(r.agent, r.model || null))
+    }
+    const left = dropped.length ? ` ${dropped.join(', ')} ${dropped.length > 1 ? 'were' : 'was'} left off: the default ladder keeps only the agents Settings can express (${saveable.join(', ')}).` : ''
+    if (!ladder.length) {
+      toast(dropped.length
+        ? `The default ladder was left alone: it would keep no rung at all.${left}`
+        : 'The default ladder was left alone: a scripted test agent cannot be a rung.')
+      return
+    }
+    try {
+      const data = await api('/api/settings', { method: 'PATCH', body: { handoff_ladder: ladder } })
+      state.preferences = data.preferences || state.preferences
+      entryState.ladderStart = 0
+      entryState.model = undefined
+      renderEntryLine()
+      toast(`Saved as your default ladder: ${ladder.map(ladderLabel).join(' then ')}.${left}`)
+    } catch (err) {
+      toast(`The card was created. The default ladder was not saved: ${err.message}`)
+    }
   }
 
   async function openNewCardDialog() {
     if (!state.adapters) {
       try { state.adapters = (await api('/api/adapters')).adapters } catch (err) { toast(err.message); return }
     }
+    // neither of these stops the dialog opening: without a catalog every model
+    // select offers the provider default, and without preferences the rows fall
+    // back to the agents that are installed
+    if (!state.models) { try { state.models = (await api('/api/models')).models; publishModels() } catch { /* provider default only */ } }
+    if (!state.preferences) { try { state.preferences = (await api('/api/settings')).preferences || null } catch { /* installed adapters only */ } }
+
     const ui = newCardDialogEls()
     ui.form.reset()
     ui.error.hidden = true
     ui.error.textContent = ''
+    // More settings is the same sentence with more fields, so the sentence
+    // comes with it: on this page from the row above, and from /floor through
+    // the #new-card hash, which is how that page reaches this dialog without a
+    // second copy of its markup.
+    if (entryState.task && entryState.task.trim()) ui.task.value = entryState.task
+    // the workflow is one of the row's three nouns and it went the same way the
+    // task does. form.reset() above puts the select back to the option marked
+    // selected in the markup (build), so this has to run after it.
+    if (entryState.pipeline) ui.pipeline.value = entryState.pipeline
     ui.customPipeline.hidden = ui.pipeline.value !== 'custom'
-    const real = (state.adapters || []).filter((a) => !a.fake)
-    ui.firstAgent.textContent = ''
-    for (const adapter of real) ui.firstAgent.appendChild(el('option', { value: adapter.name }, [adapter.name]))
-    if (real.some((a) => a.name === 'claude')) ui.firstAgent.value = 'claude'
+
+    // the repo and branch the entry row would have used, and every repo this
+    // board has seen, so the commonest case is already filled in
+    const repo = entryRepo()
+    ui.repoKnown.textContent = ''
+    for (const r of knownRepos()) ui.repoKnown.appendChild(el('option', { value: r.path }, [r.name]))
+    ui.repoKnown.appendChild(el('option', { value: '' }, ['Another path, typed below']))
+    ui.repoKnown.value = repo ? repo.path : ''
+    ui.repo.value = repo ? repo.path : ''
+    ui.trunk.value = entryTrunk(repo) || 'main'
+
     ui.testAdapter.textContent = ''
-    ui.testAdapter.appendChild(el('option', { value: '' }, ['Use the real first agent above']))
+    ui.testAdapter.appendChild(el('option', { value: '' }, ['Use the real first row above']))
     for (const adapter of (state.adapters || []).filter((a) => a.fake)) ui.testAdapter.appendChild(el('option', { value: adapter.name }, [adapterLabel(adapter)]))
-    ui.firstControls.textContent = ''
-    ui.chainRows.textContent = ''
-    rebuildFirstControls(ui)
-    rebuildDefaultFallbacks(ui)
+
+    const rungs = entryChain()
+    ncRows = rungs.length ? rungs.map((r) => ncRow(r.agent, r.model || '')) : []
+    if (!ncRows.length && (state.adapters || []).length) ncRows = [ncRow(ncNextAgent(), '')]
+    ui.saveLadder.checked = false
+    renderChainRows(ui)
     ui.dialog.showModal()
   }
 
   async function submitNewCard(e) {
     e.preventDefault()
     const ui = newCardDialogEls()
-    const rows = [...ui.firstControls.children, ...ui.chainRows.children]
-      .filter((row) => row.fields)
-      .map((row) => ({
-        adapter: row.fields.adapterSelect.value,
-        mode: row.fields.modeSelect.value,
-        approve: row.fields.approveCheckbox.checked,
-        turns: row.fields.turnsInput.value.trim(),
-        fake: row.fields.fakeInput.hidden ? '' : row.fields.fakeInput.value.trim(),
-      }))
-      .filter((r) => r.adapter)
+    const fail = (msg) => { ui.error.hidden = false; ui.error.textContent = msg }
+    const rows = ncRows.filter((r) => r.agent)
+    if (!rows.length) return fail('Add at least one row under Who runs it: a card needs an agent to run it.')
+    if (!ui.repo.value.trim()) return fail('Name the repository this card works in.')
+    // One object per row, not a comma list plus four adapter-keyed strings.
+    // The keyed form could only ever carry one mode, one turn limit and one
+    // model PER ADAPTER, so a chain of claude/fable then claude/opus lost the
+    // difference between its own two rows. src/pipeline.mjs normalizeChainEntry
+    // takes every one of these fields per entry.
+    const chain = rows.map((r) => ({
+      adapter: r.agent,
+      ...(r.model ? { model: r.model } : {}),
+      ...(r.mode ? { mode: r.mode } : {}),
+      ...(String(r.turns).trim() ? { maxTurns: Number(String(r.turns).trim()) } : {}),
+      ...(r.approve ? { approve: true } : {}),
+      ...(String(r.fake).trim() ? { fakeMode: String(r.fake).trim() } : {}),
+    }))
 
     const body = {
       repo: ui.repo.value.trim(),
       task: ui.task.value.trim(),
-      chain: rows.map((r) => r.adapter).join(','),
+      chain,
       pipeline: ui.pipeline.value === 'custom' ? ui.customPipeline.value.trim() : ui.pipeline.value,
       leases: ui.leases.value.trim(),
       trunk: ui.trunk.value.trim() || 'main',
       land_mode: ui.landMode.value,
       test_command: ui.testCommand.value.trim(),
       title: ui.title.value.trim(),
-      mode: rows.filter((r) => r.mode).map((r) => `${r.adapter}=${r.mode}`).join(','),
-      approve: rows.filter((r) => r.approve).map((r) => r.adapter).join(','),
-      maxTurns: rows.filter((r) => r.turns).map((r) => `${r.adapter}=${r.turns}`).join(','),
-      fake_mode: rows.filter((r) => r.fake).map((r) => `${r.adapter}=${r.fake}`).join(','),
       queue: ui.queue.checked,
     }
     try {
       const data = await api('/api/cards', { method: 'POST', body })
+      // the card exists now: a ladder that will not save is a toast, never a
+      // reason to leave the dialog open over a card that was already created
+      if (ui.saveLadder.checked) await saveLadderFromRows(rows)
       ui.dialog.close()
+      // the sentence was sent, so the row that carried it here is spent: a row
+      // left armed makes the next Start post the same card a second time.
+      // upsertCard redraws the row, so there is no render call to add.
+      entryState.task = ''
+      entryState.editing = null
       upsertCard(data.card)
     } catch (err) {
-      ui.error.hidden = false
-      ui.error.textContent = err.message
+      fail(err.message)
     }
   }
 
@@ -1181,9 +1570,24 @@
     ui.form.addEventListener('submit', submitNewCard)
     ui.cancel.addEventListener('click', () => ui.dialog.close())
     ui.pipeline.addEventListener('change', () => { ui.customPipeline.hidden = ui.pipeline.value !== 'custom' })
-    ui.firstAgent.addEventListener('change', () => { ui.testAdapter.value = ''; rebuildFirstControls(ui); rebuildDefaultFallbacks(ui) })
-    ui.testAdapter.addEventListener('change', () => rebuildFirstControls(ui))
-    ui.addRowBtn.addEventListener('click', () => addChainRow(ui))
+    // the picker fills the path field rather than replacing it: the path is
+    // what gets posted, and a reader who wants a repo the board has never seen
+    // types it in the same box
+    ui.repoKnown.addEventListener('change', () => {
+      if (!ui.repoKnown.value) { ui.repo.focus(); return }
+      ui.repo.value = ui.repoKnown.value
+      const known = knownRepos().find((r) => r.path === ui.repoKnown.value) || { path: ui.repoKnown.value, name: ui.repoKnown.value }
+      ui.trunk.value = entryTrunk(known) || 'main'
+    })
+    // unchanged meaning: the scripted adapter replaces the agent on the first
+    // row, and clearing it puts the first real agent back
+    ui.testAdapter.addEventListener('change', () => {
+      if (!ncRows.length) ncRows = [ncRow(ncNextAgent(), '')]
+      const real = realAdapters()
+      ncRows[0] = ncRow(ui.testAdapter.value || real[0] || ncRows[0].agent, '')
+      renderChainRows(ui)
+    })
+    ui.addRowBtn.addEventListener('click', () => { ncRows.push(ncRow(ncNextAgent(), '')); renderChainRows(ui) })
   }
 
   // ---- 6.10 settings: the last region of the page, in flow ----
@@ -1235,6 +1639,15 @@
     if (meta) meta.textContent = panel.meta
   }
 
+  // The process behind the page is older or newer than the page itself. Said
+  // once, as an error that stays until dismissed, because everything the reader
+  // sees from here on is drawn by files the process does not know about.
+  function versionSkew(processVersion) {
+    if (!processVersion || processVersion === FILES_VERSION) return false
+    toast(`This board process runs leg ${processVersion} and the page files are ${FILES_VERSION}. Restart it to match: leg down && leg up`)
+    return true
+  }
+
   function renderBoardFacts(health) {
     const box = document.querySelector('.region-settings .board-facts')
     if (!box) return
@@ -1242,8 +1655,9 @@
     const you = health.you || {}
     const share = you.share || { on: false, people: 0 }
     const sched = health.scheduler
+    const skew = health.version && health.version !== FILES_VERSION ? `, page files ${FILES_VERSION}` : ''
     const lines = [
-      `leg ${health.version}, bound to ${state.bind}`,
+      `leg ${health.version}${skew}, bound to ${state.bind}`,
       `signed in as ${you.name || 'local'}, ${you.role || 'owner'}`,
       share.on ? `share on, ${share.people === 1 ? '1 person' : `${share.people} people`}` : 'share off, nobody invited',
     ]
@@ -1292,6 +1706,39 @@
     renderTokenMeta()
   }
 
+  // ---- what /floor sends over in the address bar ----
+  // The floor starts cards from its own copy of the entry row, but the New card
+  // dialog's markup exists once, on this page, so the floor's More settings and
+  // its card titles are links here. `#new-card` opens the dialog, `#new-card=<task>`
+  // opens it with the sentence the reader had already typed, and `#card=<id>`
+  // expands that card's detail region. The hash is cleared once it is acted on:
+  // a reload should not reopen a dialog the reader closed.
+  async function openFromHash() {
+    const hash = decodeURIComponent(String((location && location.hash) || '').replace(/^#/, ''))
+    if (!hash) return
+    const clear = () => { try { history.replaceState(null, '', location.pathname + location.search) } catch { /* a browser that refuses is still on the right page */ } }
+    if (hash.startsWith('new-card')) {
+      // `#new-card=<task>&pipeline=<p>` or `#new-card?pipeline=<p>`: the floor's
+      // entry row sends both, and the dialog opens on what the reader chose
+      const rest = hash.slice('new-card'.length)
+      const m = rest.match(/[&?]pipeline=([a-z_-]+)$/)
+      const task = rest.replace(/[&?]pipeline=[a-z_-]+$/, '').replace(/^=/, '')
+      if (task) entryState.task = task
+      // an unknown word is harmless: the dialog's select ignores a value it has no option for
+      if (m) entryState.pipeline = m[1]
+      if (task || m) renderEntryLine()
+      clear()
+      await openNewCardDialog()
+      return
+    }
+    if (hash.startsWith('card=')) {
+      const id = hash.slice('card='.length)
+      clear()
+      if (!state.cards.has(id)) await fetchCards()
+      if (state.cards.has(id)) expandRow(id)
+    }
+  }
+
   // ---- init ----
   async function init() {
     initSettings()
@@ -1305,10 +1752,27 @@
       if (state.drawerId) collapseRow()
     })
     // health first: it says whether this human owns the pipeline side at all
-    await loadHealth()
+    const owner = await loadHealth()
     fetchCards()
     connectSse()
     setInterval(tickElapsed, 1000)
+    // C.2: the ladder sentence on the entry line reads this; a guest never
+    // sees the entry line, so there is nothing to fetch it for
+    if (owner) {
+      // three independent reads, so they go out together: the ladder the entry
+      // line names, the adapters that are actually installed (the fallback when
+      // there is no ladder at all), and the model catalog both selects use
+      await Promise.all([
+        api('/api/settings').then((d) => { state.preferences = d.preferences || null }).catch(() => {}),
+        api('/api/adapters').then((d) => { state.adapters = d.adapters || null }).catch(() => {}),
+        api('/api/models').then((d) => { state.models = d.models || null }).catch(() => {}),
+      ])
+      publishModels()
+      renderEntryLine()
+      // last, so the dialog opens over a page that already knows its ladder,
+      // its repos and its cards
+      await openFromHash()
+    }
   }
 
   document.addEventListener('DOMContentLoaded', init)