@ucsandman/legcli 0.8.0 → 0.10.0

package/scripts/sync-leg-agents.mjs

@@ -0,0 +1,127 @@
+#!/usr/bin/env node
+// Keep packages/leg-agents on the same version as @ucsandman/legcli.
+// Source of truth: the root package.json version and engines.node.
+//
+//   node scripts/sync-leg-agents.mjs          write version, pin, LICENSE, NOTICE
+//   node scripts/sync-leg-agents.mjs --check  exit 1 if any of those drifted
+//
+// npm test runs --check. `npm version` runs the writer so a bump cannot
+// leave the alias behind.
+import { copyFileSync, readFileSync, writeFileSync } from 'node:fs'
+import { execFileSync } from 'node:child_process'
+import { dirname, join, resolve } from 'node:path'
+import { fileURLToPath, pathToFileURL } from 'node:url'
+import { resolveCommand } from '../src/commands.mjs'
+
+export const ALIAS_NAME = 'leg-agents'
+export const PRIMARY_NAME = '@ucsandman/legcli'
+export const PACKED_FILES = ['package.json', 'bin/leg.mjs', 'LICENSE', 'NOTICE', 'README.md']
+
+const root = join(dirname(fileURLToPath(import.meta.url)), '..')
+
+export function inspect (rootDir = root) {
+  const alias = join(rootDir, 'packages', 'leg-agents')
+  const rootPkg = JSON.parse(readFileSync(join(rootDir, 'package.json'), 'utf8'))
+  const aliasPkg = JSON.parse(readFileSync(join(alias, 'package.json'), 'utf8'))
+  const wrapper = readFileSync(join(alias, 'bin', 'leg.mjs'), 'utf8')
+  const rootLicense = readFileSync(join(rootDir, 'LICENSE'))
+  const rootNotice = readFileSync(join(rootDir, 'NOTICE'))
+  const aliasLicense = readFileSync(join(alias, 'LICENSE'))
+  const aliasNotice = readFileSync(join(alias, 'NOTICE'))
+  const problems = []
+
+  if (rootPkg.name !== PRIMARY_NAME) {
+    problems.push(`root package name is ${rootPkg.name}, expected ${PRIMARY_NAME}`)
+  }
+  if (aliasPkg.name !== ALIAS_NAME) {
+    problems.push(`alias package name is ${aliasPkg.name}, expected ${ALIAS_NAME}`)
+  }
+  if (aliasPkg.version !== rootPkg.version) {
+    problems.push(`alias version ${aliasPkg.version} != ${PRIMARY_NAME} ${rootPkg.version}`)
+  }
+  const pin = aliasPkg.dependencies?.[PRIMARY_NAME]
+  if (pin !== rootPkg.version) {
+    problems.push(`alias pins ${PRIMARY_NAME}@${pin ?? '(missing)'}, expected ${rootPkg.version}`)
+  }
+  if (aliasPkg.engines?.node !== rootPkg.engines?.node) {
+    problems.push(`alias engines.node ${aliasPkg.engines?.node} != root ${rootPkg.engines?.node}`)
+  }
+  if (aliasPkg.bin?.leg !== 'bin/leg.mjs') {
+    problems.push(`alias bin.leg is ${aliasPkg.bin?.leg}, expected bin/leg.mjs`)
+  }
+  if (!Array.isArray(rootPkg.files) || rootPkg.files.includes('packages') || rootPkg.files.some((f) => String(f).startsWith('packages/'))) {
+    problems.push('root package.json files must not ship packages/leg-agents')
+  }
+  if (!rootLicense.equals(aliasLicense)) problems.push('packages/leg-agents/LICENSE does not match root LICENSE')
+  if (!rootNotice.equals(aliasNotice)) problems.push('packages/leg-agents/NOTICE does not match root NOTICE')
+  if (!wrapper.startsWith('#!/usr/bin/env node')) {
+    problems.push('packages/leg-agents/bin/leg.mjs is missing the node shebang')
+  }
+  if (!wrapper.includes("require.resolve('@ucsandman/legcli/package.json')")) {
+    problems.push('alias wrapper does not resolve @ucsandman/legcli/package.json')
+  }
+  if (!wrapper.includes('pathToFileURL')) {
+    problems.push('alias wrapper must import via pathToFileURL so Windows absolute paths work')
+  }
+  if (!wrapper.includes("join(pkgRoot, 'bin', 'leg.mjs')")) {
+    problems.push('alias wrapper does not load bin/leg.mjs from the pinned package')
+  }
+
+  return { rootPkg, aliasPkg, wrapper, problems, aliasDir: alias }
+}
+
+export function packedFileList (dir) {
+  const { bin, args } = resolveCommand('npm pack --dry-run --json --ignore-scripts')
+  const stdout = execFileSync(bin, args, { cwd: dir, encoding: 'utf8', windowsHide: true })
+  const startArr = stdout.indexOf('[')
+  const startObj = stdout.indexOf('{')
+  const start = startArr === -1 ? startObj : startObj === -1 ? startArr : Math.min(startArr, startObj)
+  if (start === -1) throw new Error(`npm pack produced no JSON:\n${stdout}`)
+  const parsed = JSON.parse(stdout.slice(start))
+  const entry = Array.isArray(parsed) ? parsed[0] : parsed
+  const files = (entry.files || []).map((f) => f.path || f)
+  return files.sort()
+}
+
+export function sync (rootDir = root) {
+  const { rootPkg, aliasPkg } = inspect(rootDir)
+  const alias = join(rootDir, 'packages', 'leg-agents')
+  const next = {
+    ...aliasPkg,
+    version: rootPkg.version,
+    dependencies: { ...aliasPkg.dependencies, [PRIMARY_NAME]: rootPkg.version },
+    engines: { ...aliasPkg.engines, node: rootPkg.engines.node }
+  }
+  writeFileSync(join(alias, 'package.json'), JSON.stringify(next, null, 2) + '\n')
+  copyFileSync(join(rootDir, 'LICENSE'), join(alias, 'LICENSE'))
+  copyFileSync(join(rootDir, 'NOTICE'), join(alias, 'NOTICE'))
+  return next
+}
+
+const isMain = Boolean(process.argv[1]) && import.meta.url === pathToFileURL(resolve(process.argv[1])).href
+
+if (isMain) {
+  const check = process.argv.includes('--check')
+  if (!check) sync()
+  const { rootPkg, problems, aliasDir: dir } = inspect()
+  let packed
+  try {
+    packed = packedFileList(dir)
+  } catch (error) {
+    problems.push(`npm pack --dry-run failed: ${error.message}`)
+  }
+  if (packed) {
+    const expected = [...PACKED_FILES].sort()
+    if (packed.join('\n') !== expected.join('\n')) {
+      problems.push(`packed files are [${packed.join(', ')}], expected [${expected.join(', ')}]`)
+    }
+  }
+  if (problems.length) {
+    console.error(`leg-agents is out of lockstep with ${PRIMARY_NAME}@${rootPkg.version}:\n`)
+    for (const p of problems) console.error(`  - ${p}`)
+    console.error('\nRun: node scripts/sync-leg-agents.mjs')
+    process.exitCode = 1
+  } else {
+    console.log(`leg-agents: in lockstep with ${PRIMARY_NAME}@${rootPkg.version}`)
+  }
+}

package/src/accounts.mjs

@@ -43,13 +43,15 @@ export const LAYOUT = {
 export function accountsFile() { return join(home(), 'accounts.json') }
 export function accountDir(agent, name) { return join(home(), 'accounts', agent, name) }
 
+const NAME_RE = /^[a-z0-9][a-z0-9_-]{0,29}$/i
+
 export function readAccounts() {
-  const base = { claude: ['default'], codex: ['default'], agy: ['default'] }
+  const base = { claude: ['default'], codex: ['default'], agy: ['default'], grok: ['default'] }
   if (!existsSync(accountsFile())) return base
   try {
     const j = JSON.parse(readFileSync(accountsFile(), 'utf8'))
-    for (const k of Object.keys(base)) if (Array.isArray(j[k])) base[k] = ['default', ...j[k].filter((n) => n !== 'default')]
-    if (Array.isArray(j?.grok)) base.grok = ['default', ...j.grok.filter((n) => n !== 'default')]
+    // the same shape addAccount accepts: a name is a directory segment, never a path
+    for (const k of Object.keys(base)) if (Array.isArray(j[k])) base[k] = ['default', ...j[k].filter((n) => typeof n === 'string' && n !== 'default' && NAME_RE.test(n))]
   } catch {}
   return base
 }
@@ -75,7 +77,7 @@ function junction(target, link) {
 
 // Create the account dir, junction the shared harness in, copy the settings.
 export function addAccount(agent, name) {
-  if (!/^[a-z0-9][a-z0-9_-]{0,29}$/i.test(name) || name === 'default') throw new Error(`invalid account name "${name}" (letters, digits, - and _; not "default")`)
+  if (!NAME_RE.test(name) || name === 'default') throw new Error(`invalid account name "${name}" (letters, digits, - and _; not "default")`)
   const l = LAYOUT[agent]
   if (!l) throw new Error(`unknown agent "${agent}" (claude|codex|agy|grok)`)
   if (!l.env) throw new Error(`${agent} has no config-dir override in the installed version; extra accounts are not possible`)

package/src/adapters/codex.mjs

@@ -19,7 +19,7 @@ const adapter = {
   forbiddenFlags: ['danger-full-access', '--dangerously-bypass-approvals-and-sandbox', '--dangerously-bypass-hook-trust', '--full-auto', '--approve-for-me'],
   resolve() {
     if ((process.env.LEG_CODEX_BIN || process.env.BATON_CODEX_BIN)) {
-      const bin = process.env.BATON_CODEX_BIN
+      const bin = process.env.LEG_CODEX_BIN || process.env.BATON_CODEX_BIN
       return { bin, viaNode: /\.(mjs|cjs|js)$/.test(bin), entry: null }
     }
     // The npm package's bin/codex.js only spawns the platform package's native

package/src/attach.mjs

@@ -1,5 +1,5 @@
-// attach — `baton claude|codex|agy [args…]`: the normal interactive agent in
-// this terminal, with Baton alongside it. Baton (1) makes sure the board is
+// attach — `leg claude|codex|agy [args…]`: the normal interactive agent in
+// this terminal, with Leg alongside it. Leg (1) makes sure the board is
 // up and opens it once, (2) registers the session so it shows on the board,
 // (3) taps the agent for usage (claude: hooks + status line via --settings;
 // codex: its rollout file; agy: its log), (4) polls git for the files the
@@ -8,6 +8,7 @@
 // same terminal from that bundle. Subscription logins only: API keys are
 // stripped from the child environment (src/env.mjs).
 import http from 'node:http'
+import net from 'node:net'
 import { spawn, spawnSync } from 'node:child_process'
 import { existsSync, mkdirSync, writeFileSync, rmSync } from 'node:fs'
 import { join, dirname, resolve, relative } from 'node:path'
@@ -28,16 +29,27 @@ import { findRollout, createTail, parseLines, readCodexUsage, transcriptTail as
 import { scanLog, promptsSince, logSize } from './taps/agy.mjs'
 import { fetchGrokUsage, scanLog as scanGrokLog, promptsSince as grokPromptsSince } from './taps/grok.mjs'
 import { fetchClaudeUsage } from './taps/claude-usage.mjs'
-import { saveSessionBundle, resumePrompt } from './bundle.mjs'
+import { saveSessionBundle, resumePrompt, sessionCommitDelta } from './bundle.mjs'
 import { endSessionPointer } from './resume.mjs'
 import { openBoard, pidfile } from './launcher.mjs'
 import { LAYOUT } from './accounts.mjs'
 import { captureLive } from './live-capture.mjs'
 import { waitForReset, fmtCountdown } from './wait.mjs'
 import { readPreferences, normalizeHandoffOrder, resolveAutoApprove } from './preferences.mjs'
+import { prepareHarnessForHandoff, harnessLine } from './harness/index.mjs'
+import { insideKnownStore } from './history/index.mjs'
 
 const SRC = dirname(fileURLToPath(import.meta.url))
-const SERVER = join(SRC, 'server.mjs')
+function resolveServer() {
+  const wtMatch = /[\\/]\.(?:leg|baton)-worktrees(?:[\\/].*)?$/.exec(SRC)
+  if (wtMatch) {
+    const root = SRC.slice(0, wtMatch.index)
+    const mainServer = join(root, 'src', 'server.mjs')
+    if (existsSync(mainServer)) return mainServer
+  }
+  return join(SRC, 'server.mjs')
+}
+const SERVER = resolveServer()
 const POLL_MS = Number(process.env.LEG_ATTACH_POLL_MS || process.env.BATON_ATTACH_POLL_MS || 2000)
 const GIT_EVERY = 3 // polls
 const USAGE_MS = Number(process.env.LEG_USAGE_POLL_MS || process.env.BATON_USAGE_POLL_MS || 60000)
@@ -70,6 +82,19 @@ function health(port, host = '127.0.0.1') {
   })
 }
 
+// Does anything own this port? A completed TCP connect is the question, so a
+// board too busy to answer /api/health still counts as one. Nothing is sent.
+function portTaken(port, host = '127.0.0.1') {
+  return new Promise((res) => {
+    const sock = net.connect({ host: host === '0.0.0.0' ? '127.0.0.1' : host, port })
+    const done = (v) => { sock.destroy(); res(v) }
+    sock.setTimeout(2000)
+    sock.on('connect', () => done(true))
+    sock.on('error', () => done(false))
+    sock.on('timeout', () => done(false))
+  })
+}
+
 export async function ensureBoard({ open = true } = {}) {
   // with share on the board lives on the shared address, not loopback
   const share = readShare()
@@ -78,18 +103,31 @@ export async function ensureBoard({ open = true } = {}) {
   const host = shared ? share.bind : '127.0.0.1'
   const url = `http://${host}:${port}`
   if ((process.env.LEG_NO_BOARD || process.env.BATON_NO_BOARD) === '1') return { url: null, started: false, skipped: true }
-  if (await health(port, host)) return { url, started: false }
+  // the board is opened whether or not this terminal is the one that started
+  // it: `leg claude` in a second terminal still means "show me the board"
+  if (await health(port, host)) { if (open) openBoard(url); return { url, started: false } }
+  // A board that is merely busy misses the health deadline while still owning
+  // the port. Treating that as "no board" spawned a second server that could
+  // only die of EADDRINUSE, and the poll below then waited the full fifteen
+  // seconds for a child already gone — the whole delay before the agent
+  // starts, and the reason no browser ever opened. A listener on the port is
+  // a board: attach to it and open it.
+  if (await portTaken(port, host)) {
+    say(`the board on ${url} is busy; attaching to it`)
+    if (open) openBoard(url)
+    return { url, started: false, busy: true }
+  }
   mkdirSync(home(), { recursive: true })
   const logFd = (await import('node:fs')).openSync(join(home(), 'board.log'), 'a')
-  const child = spawn(process.execPath, [SERVER], { detached: true, windowsHide: true, stdio: ['ignore', logFd, logFd], env: { ...process.env, BATON_PORT: String(port), BATON_BIND: host, BATON_QUIET: '0' } })
+  const child = spawn(process.execPath, [SERVER], { detached: true, windowsHide: true, stdio: ['ignore', logFd, logFd], env: { ...process.env, LEG_PORT: String(port), LEG_BIND: host, LEG_QUIET: '0', BATON_PORT: String(port), BATON_BIND: host, BATON_QUIET: '0' } })
   child.unref()
   const t0 = Date.now()
   while (Date.now() - t0 < 15000) {
     const h = await health(port, host)
     if (h) {
       // only claim the pidfile for a child we actually started: under a race,
-      // another `baton` won the port and ours died on EADDRINUSE — writing our
-      // dead pid would make `baton down` kill nothing and report "not running"
+      // another `leg` won the port and ours died on EADDRINUSE — writing our
+      // dead pid would make `leg down` kill nothing and report "not running"
       const ours = h.pid ? h.pid === child.pid : (child.exitCode === null && Boolean(child.pid))
       if (ours) writeFileSync(pidfile(), JSON.stringify({ pid: child.pid, port, bind: host, children: [child.pid], detached: true, started_by: 'attach', started_at: new Date().toISOString() }, null, 2) + '\n')
       if (open) openBoard(url)
@@ -195,7 +233,7 @@ export async function spawnSpec(agent, { account, args, sessionId, prompt, cwd,
   const argv = []
   // viaNode: either an npm entry (codex bin/codex.js) or a BATON_<AGENT>_BIN that names a .mjs (tests)
   if (viaNode) argv.push(entry ?? bin)
-  // a leg Baton starts on its own (after a hand-off) takes BATON_<AGENT>_ARGS,
+  // a leg Leg starts on its own (after a hand-off) takes BATON_<AGENT>_ARGS,
   // e.g. BATON_CODEX_ARGS="-m gpt-5-mini" to keep a test chain on cheap models
   if (prompt) args = [...(process.env[`LEG_${agent.toUpperCase()}_ARGS`] ?? process.env[`BATON_${agent.toUpperCase()}_ARGS`] ?? '').split(/\s+/).filter(Boolean), ...args]
   if (agent === 'claude') {
@@ -259,6 +297,13 @@ async function runLeg({ agent, account, args, session, prompt, boardUrl, autoApp
 
   // taps
   let rollout = null; let tail = null
+  // a continued codex thread appends to its old rollout, which findRollout
+  // (newest file since this leg started) would never pick: bind it up front
+  // and read only what the thread writes from here on
+  if (agent === 'codex' && !prompt && session.transcript_path && session.agent_session_id && existsSync(session.transcript_path)) {
+    rollout = { path: session.transcript_path, meta: { id: session.agent_session_id } }
+    tail = createTail(rollout.path, { from: logSize(rollout.path) })
+  }
   let polls = 0; let warned = false
   let stop = null
   const done = new Promise((res) => { stop = res })
@@ -484,14 +529,14 @@ function messagesFor(agent, s) {
 // an order save is consumed here, or the editor sees handing_off and refuses.
 // No eligible choice leaves the session unclaimed so all-out waiting can keep
 // accepting order edits.
-export function claimHandoffChoice({ sid, agent, account, installed, bundle = null, reason = 'limit', nowS = Math.floor(Date.now() / 1000) }) {
+export function claimHandoffChoice({ sid, agent, account, installed, bundle = null, reason = 'limit', nowS = Math.floor(Date.now() / 1000), exclude = [] }) {
   let choice = { next: null, out: [] }
   let claimed = false
   const session = updateSession(sid, (current) => {
     const accounts = readAccounts()
     const order = normalizeHandoffOrder(current.handoff_order)
-    choice = chooseNext({ agent, account, accounts, installed, order, nowS })
-    if (!choice.next && isAvailable(readUsage(agent, account), nowS)) choice = { next: { agent, account }, out: [] }
+    choice = chooseNext({ agent, account, accounts, installed, order, nowS, exclude })
+    if (!choice.next && isAvailable(readUsage(agent, account), nowS) && !exclude.some((x) => x.agent === agent && x.account === account)) choice = { next: { agent, account }, out: [] }
     if (!choice.next) return {}
     claimed = true
     return {
@@ -510,15 +555,34 @@ export function claimHandoffChoice({ sid, agent, account, installed, bundle = nu
   return { choice, claimed, session }
 }
 
+// The portable harness, decided before a leg starts (src/harness/index.mjs).
+// Off by default: then this records nothing and changes nothing. On, it
+// carries the source agent's working environment to the agent about to run,
+// per the saved policy, and the session keeps the outcome so the board can say
+// what transferred and what did not. Never throws into the session.
+function prepareLegHarness({ sid, from, to }) {
+  let outcome
+  try { outcome = prepareHarnessForHandoff({ from, to, sessionId: sid }) } catch (err) { outcome = { state: 'error', policy: 'unknown', proceed: true, to, target: to, reason: String(err.message).slice(0, 200), summary: `harness error: ${String(err.message).slice(0, 120)}` } }
+  if (outcome.state === 'off') return outcome
+  updateSession(sid, { harness: outcome })
+  const line = harnessLine(outcome)
+  if (line) { say(line); appendEvent(sid, { type: outcome.proceed ? 'harness' : 'harness_blocked', summary: line, body: outcome.dropped?.length || outcome.attention?.length ? [...(outcome.attention ?? []).map((a) => `attention ${a.component}: ${a.reason}`), ...(outcome.dropped ?? []).map((d) => `dropped ${d.component}: ${d.item}: ${d.reason}`)].join('\n') : undefined }) }
+  return outcome
+}
+
 // ---- the command ----
-export async function attach(agent, args = [], { open = true } = {}) {
+// `cwd` and `continued` are how `leg history continue` starts a leg on a
+// conversation the agent's own store holds (src/history/cli.mjs): the leg runs
+// in that conversation's folder, shares the checkout (its files are already
+// there), and the session record carries the agent's id from the start.
+export async function attach(agent, args = [], { open = true, cwd: cwdOpt = null, continued = null } = {}) {
   if (!SUPERVISED_AGENTS.includes(agent)) throw new Error(`unknown agent "${agent}" (claude|codex|agy|grok)`)
   // the paid gate: a valid key, or no session (exit 4). The bare agent is never
-  // affected; only what Baton adds is licensed.
+  // affected; only what Leg adds is licensed.
   const ent = entitlement()
   if (!allows(ent, 'run')) { say(describeLicense(ent)); return 4 }
-  // --no-worktree is Baton's flag, not the agent's: it never passes through
-  const shareCheckout = args.includes('--no-worktree')
+  // --no-worktree is Leg's flag, not the agent's: it never passes through
+  const shareCheckout = args.includes('--no-worktree') || Boolean(continued)
   args = args.filter((a) => a !== '--no-worktree')
   let autoApproveCli = null
   if (args.includes('--no-auto-approve')) {
@@ -529,7 +593,7 @@ export async function attach(agent, args = [], { open = true } = {}) {
     args = args.filter((a) => a !== '--auto-approve')
   }
   const autoApprove = resolveAutoApprove({ cliFlag: autoApproveCli })
-  const cwd = process.cwd()
+  const cwd = cwdOpt ? realPath(cwdOpt) : process.cwd()
   const board = await ensureBoard({ open })
   let accounts = readAccounts()
   const installed = await installedAgents()
@@ -562,6 +626,13 @@ export async function attach(agent, args = [], { open = true } = {}) {
   // `git worktree add` still leaves a card (with a Remove button), never a
   // silent orphan under .baton-worktrees with no record and no button
   createSession({ id: sid, agent, account, cwd, repo: g.repo, branch: g.branch, argv: args, chain, worktree: null, owner: whoami(), handoffOrder, installed, runtimeCapabilities: [HANDOFF_ORDER_CAPABILITY] })
+  if (continued) {
+    // the agent's own id and transcript are known before the first turn, so
+    // history dedups this leg against the conversation it continues at once
+    const safeTranscript = (continued.transcript_path && insideKnownStore(continued.transcript_path)) ? continued.transcript_path : null
+    updateSession(sid, { agent_session_id: continued.native_id ?? null, transcript_path: safeTranscript, task: continued.title ?? null, continued_from: { id: continued.id, provider: continued.provider, native_id: continued.native_id ?? null } },
+      { event: { type: 'continued', summary: `continuing ${continued.id}${continued.title ? `: ${String(continued.title).slice(0, 120)}` : ''}` } })
+  }
   let iso = null
   if (g.repo && !shareCheckout) {
     try { iso = isolate({ g, cwd, sid }) } catch (err) { say(`could not make a worktree (${String(err.message).split('\n')[0].slice(0, 200)}); sharing the checkout`); try { removeWorktree(g.repo, sid) } catch {} }
@@ -578,6 +649,9 @@ export async function attach(agent, args = [], { open = true } = {}) {
   let prompt = null
   let legArgs = args
   let exit = 0
+  // the first leg is the agent the human chose: its harness is prepared per
+  // policy and recorded, never refused (strict applies to hand-offs)
+  prepareLegHarness({ sid, from: null, to: agent })
   // unbounded: the 12-leg cap below stops a runaway chain, and the all-out wait
   // bounds a wait; a normal session runs one leg and exits
   for (let leg = 0; ; leg++) {
@@ -593,10 +667,14 @@ export async function attach(agent, args = [], { open = true } = {}) {
     // saveSessionBundle writes the notes file before it shells out to chb, so
     // even when chb is missing and the save throws, the context is on disk
     const notesFile = join(workRoot(cur) ?? cur.cwd, '.leg', `session-${sid}.md`)
-    let claim = claimHandoffChoice({ sid, agent, account, installed, bundle, reason: r.reason })
+    // destinations the strict harness policy refused during this hand-off
+    const excluded = []
+    let claim = claimHandoffChoice({ sid, agent, account, installed, bundle, reason: r.reason, exclude: excluded })
     let choice = claim.choice
     let cancelled = false
+    let blocked = false
     while (!choice.next) {
+      if (excluded.length && !choice.out.length) { blocked = true; break }
       // every option is out: keep the terminal, count down to the SOONEST reset
       // (the current agent's own wall included — it may be the first back), then
       // start that option from the bundle. Ctrl-C (or End) quits with exit 3.
@@ -612,7 +690,7 @@ export async function attach(agent, args = [], { open = true } = {}) {
       updateSession(sid, { status: 'waiting', all_out: all, waiting: first ? { agent: first.agent, account: first.account, resets_at: first.resets_at, since: new Date().toISOString() } : null }, { event: { type: 'all_out', summary: `every option is out; waiting for ${label} at ${first ? fmtReset(first.resets_at) : 'unknown'}` } })
       const r2 = await waitInTerminal({ sid, label, resetsAt: first?.resets_at ?? null })
       if (r2 === 'cancelled') { cancelled = true; break }
-      claim = claimHandoffChoice({ sid, agent, account, installed, bundle, reason: r.reason })
+      claim = claimHandoffChoice({ sid, agent, account, installed, bundle, reason: r.reason, exclude: excluded })
       choice = claim.choice
     }
     if (cancelled) {
@@ -620,6 +698,24 @@ export async function attach(agent, args = [], { open = true } = {}) {
       exit = 3
       break
     }
+    // strict harness policy: a destination whose harness cannot be made safe is
+    // refused and the next option is tried; when none is left the session ends
+    // with exit 5 rather than launching an agent without its environment
+    while (!blocked && choice.next) {
+      const prepared = prepareLegHarness({ sid, from: agent, to: choice.next.agent })
+      if (prepared.proceed) break
+      excluded.push(choice.next)
+      say(`${choice.next.agent} refused by the strict harness policy: ${prepared.reason ?? prepared.state}`)
+      claim = claimHandoffChoice({ sid, agent, account, installed, bundle, reason: r.reason, exclude: excluded })
+      choice = claim.choice
+      if (!choice.next) blocked = true
+    }
+    if (blocked) {
+      say('every remaining option was refused by the strict harness policy; stopping (exit 5). Fix what needs attention (leg harness status) or relax the policy (leg harness policy sync), then run leg again in this directory.')
+      updateSession(sid, { status: 'ended', ended_at: new Date().toISOString(), exit_code: 5, waiting: null }, { event: { type: 'ended', summary: 'strict harness policy refused every destination; stopped (exit 5)' } })
+      exit = 5
+      break
+    }
     const next = choice.next
     // bound the number of hand-offs in one terminal so a chain that limits
     // instantly can never loop forever; stopping is explicit, not a silent exit 0
@@ -630,9 +726,15 @@ export async function attach(agent, args = [], { open = true } = {}) {
       break
     }
     appendEvent(sid, { type: 'handoff', summary: `${agent}${account !== 'default' ? '/' + account : ''} → ${next.agent}${next.account !== 'default' ? '/' + next.account : ''}${bundle ? ` (bundle ${bundle.id})` : ''}` })
-    prompt = bundle
-      ? resumePrompt(cur, bundle, next)
-      : `You are taking over an interactive coding session from ${agent}.${existsSync(notesFile) ? ` Read ${notesFile} in this directory first (the previous agent's notes: task, last messages, dirty files).` : ''} Check git status and git diff, then continue the work. The task: ${cur.task ?? 'see the recent changes'}`
+    if (bundle) {
+      prompt = resumePrompt(cur, bundle, next)
+    } else {
+      const delta = sessionCommitDelta(workRoot(cur) ?? cur.cwd, cur)
+      const fallbackAction = delta.isClean && delta.newCommits.length > 0
+        ? `The previous agent committed changes (${delta.newCommits.length} commit(s)) and left a clean working tree. Check git log and verify whether the task is already complete before doing redundant work; continue only if work remains.`
+        : 'Check git status and git diff, then continue the work.'
+      prompt = `You are taking over an interactive coding session from ${agent}.${existsSync(notesFile) ? ` Read ${notesFile} in this directory first (the previous agent's notes: task, last messages, dirty files).` : ''} ${fallbackAction} The task: ${cur.task ?? 'see the recent changes'}`
+    }
     say(`starting ${next.agent}${next.account !== 'default' ? '/' + next.account : ''} in this terminal from the bundle`)
     agent = next.agent; account = next.account; legArgs = []
     // the chain is what comes after the agent now taking over, not after the
@@ -646,7 +748,7 @@ export async function attach(agent, args = [], { open = true } = {}) {
   if (fin && fin.status !== 'ended') updateSession(sid, { status: 'ended', ended_at: new Date().toISOString(), exit_code: exit }, { event: { type: 'ended', summary: `session ended (exit ${exit})` } })
   // Every way out of the loop arrives here: a clean exit, a cancelled wait, the
   // 12-leg cap, an agent that never started. The terminal is gone, so RESUME.md
-  // must stop describing it as live — Baton owns that file, and leaving the last
+  // must stop describing it as live — Leg owns that file, and leaving the last
   // hand-off sitting there is exactly the lie this rewrite exists to stop.
   try { endSessionPointer(readSession(sid)) } catch (err) { appendEvent(sid, { type: 'error', summary: `resume pointer not rewritten: ${err.message.slice(0, 160)}` }) }
   try { rmSync(join(sessionDir(sid), 'control.json'), { force: true }) } catch {}

package/src/auth.mjs

@@ -1,6 +1,6 @@
 // auth — who is allowed in. Loopback with no token is open; any other bind
 // address refuses to start without a token, and with a token every /api
-// request needs `Authorization: Bearer <token>` (timing-safe). With `baton
+// request needs `Authorization: Bearer <token>` (timing-safe). With `leg
 // share` on, each human has their own token and the board knows their name
 // and role (src/share.mjs); a loopback request is still the owner, so the
 // machine's own browser needs nothing.
@@ -75,7 +75,7 @@ export function authorize({ token, req, url, share = null, bind = null, loopback
     return { ok: false, subject: null, person: null }
   }
   // checkBind's invariant, re-applied per request: share.json stops reading as
-  // on (`baton share off`, a truncated file) while the shared address is still
+  // on (`leg share off`, a truncated file) while the shared address is still
   // bound, and nobody but this machine may be the local owner in that window
   if (!token && loopbackOwner === false) return { ok: false, subject: null, person: null }
   if (!token && bind && !isLoopback(bind) && !isLoopback(remoteAddress(req))) return { ok: false, subject: null, person: null }

package/src/board/board.css

@@ -130,6 +130,7 @@
   --id-codex: #69DBBA;   /* oklch(0.815 0.115 172) cool green */
   --id-agy: #CC97F3;     /* oklch(0.760 0.140 310) violet, 46 degrees clear of the accent */
   --id-grok: #70B8FF;    /* oklch(0.750 0.130 240) azure blue */
+  --id-copilot: #F0A3B8; /* oklch(0.790 0.110 5) rose; lists and reads, never runs */
   --id-fake: #A0A6AE;    /* oklch(0.720 0.010 258) the scripted adapter, neutral in hue */
 
   /* type scale. Fixed rem, range 13 to 52. The old board ran 13 to 21, which
@@ -222,6 +223,7 @@ code { font-family: var(--mono); font-size: 0.94em; }
 .dot.id-codex { background: var(--id-codex); }
 .dot.id-agy { background: var(--id-agy); }
 .dot.id-grok { background: var(--id-grok); }
+.dot.id-copilot { background: var(--id-copilot); }
 
 /* ---- logins ------------------------------------------------------------- */
 .logins { display: grid; gap: 20px; }
@@ -323,6 +325,7 @@ code { font-family: var(--mono); font-size: 0.94em; }
 .chip-id-codex { color: var(--id-codex); }
 .chip-id-agy { color: var(--id-agy); }
 .chip-id-grok { color: var(--id-grok); }
+.chip-id-copilot { color: var(--id-copilot); }
 .chip-id-fake { color: var(--id-fake); }
 .chip-state-ok { color: var(--ok-text); }
 .chip-state-warn { color: var(--warn-text); }
@@ -370,7 +373,7 @@ code { font-family: var(--mono); font-size: 0.94em; }
 .drawer-msg-when { font-size: var(--t--1); color: var(--text-3); font-family: var(--mono); }
 
 /* ---- ledger: on the ground, unpanelled --------------------------------- */
-.ledger { margin-top: 56px; display: grid; grid-template-columns: repeat(3, minmax(0, 1fr)); gap: 40px; padding-top: 32px; border-top: 1px solid var(--edge); }
+.ledger { margin-top: 56px; display: grid; grid-template-columns: repeat(4, minmax(0, 1fr)); gap: 40px; padding-top: 32px; border-top: 1px solid var(--edge); }
 .ledger-cell h3 { font-size: var(--t-2); font-weight: var(--w-head); letter-spacing: -.012em; }
 .ledger-cell .region-meta { margin-top: 6px; font-size: var(--t-0); color: var(--text-3); }
 .ledger-actions { margin-top: 18px; display: flex; gap: 10px; flex-wrap: wrap; }
@@ -384,6 +387,23 @@ code { font-family: var(--mono); font-size: 0.94em; }
 .line-main { color: var(--text); }
 .line-meta { color: var(--text-2); }
 .line-when { color: var(--text-3); text-align: right; }
+/* history: the conversations every agent keeps, one row each, opening in place */
+.history-filters { display: grid; grid-template-columns: auto minmax(0, 1fr); gap: 10px 14px; align-items: center; margin: 4px 0 18px; max-width: 64ch; }
+.history-filters label { font-size: var(--t-0); font-weight: var(--w-head); color: var(--text-2); }
+.history-filters label:has(input[type="checkbox"]) { grid-column: 1 / -1; display: flex; align-items: center; gap: 8px; font-weight: var(--w-text); }
+.history-list { display: block; }
+.history-row { display: grid; grid-template-columns: minmax(0, 1fr) auto; gap: 6px 20px; align-items: baseline; padding: 12px 0; font-size: var(--t-0); }
+.history-row + .history-row, .history-row + .history-detail, .history-detail + .history-row { border-top: 1px solid var(--line); }
+.history-title { display: block; width: 100%; text-align: left; background: none; border: 0; padding: 0; font: inherit; color: var(--text); cursor: pointer; line-height: 1.4; }
+.history-title:hover { color: var(--accent-hi); }
+.history-title:focus-visible { outline: 2px solid var(--focus); outline-offset: 3px; border-radius: var(--r-control); }
+.history-register { display: flex; align-items: baseline; gap: 14px; flex-wrap: wrap; font-size: var(--t--1); color: var(--text-3); }
+.history-when { color: var(--text-3); white-space: nowrap; font-size: var(--t--1); }
+.history-detail { padding: 14px 0 20px; }
+.history-detail .kv { margin-bottom: 14px; }
+.history-command { display: flex; align-items: center; gap: 10px; flex-wrap: wrap; margin-top: 12px; font-size: var(--t-0); }
+.history-empty { font-size: var(--t-0); color: var(--text-3); padding: 12px 0; }
+
 .group-head { display: flex; align-items: baseline; gap: 10px; margin-top: 24px; margin-bottom: 4px; font-size: var(--t-0); font-weight: var(--w-head); color: var(--text-2); }
 .group-head:first-child { margin-top: 0; }
 .group-head span { font-weight: var(--w-text); color: var(--text-3); }
@@ -556,6 +576,8 @@ dialog::backdrop { background: rgba(0,0,0,.6); }
   .kv { grid-template-columns: 1fr; gap: 4px 0; }
   .kv-val + .kv-key { margin-top: 12px; }
   .ledger { grid-template-columns: 1fr; gap: 32px; margin-top: 40px; }
+  .history-row { grid-template-columns: 1fr; }
+  .history-filters { grid-template-columns: 1fr; }
   .line { grid-template-columns: 1fr auto; gap: 6px 14px; }
   .line-main { grid-column: 1 / -1; }
   .line-meta { grid-column: 1; }

package/src/board/board.js

@@ -253,10 +253,10 @@
   }
 
   function formatActor(actor) {
-    if (!actor) return 'baton'
+    if (!actor) return 'leg'
     if (actor.type === 'human') return `human:${actor.id || 'local'}`
     if (actor.type === 'agent') return `agent:${actor.adapter || '?'}`
-    return 'baton'
+    return 'leg'
   }
 
   function baseAdapterName(name) { return String(name || '').replace(/^fake-/, '') }
@@ -292,6 +292,15 @@
       : `${s === 'reconnecting' ? 'Reconnecting' : 'Connecting'} to Leg on ${state.bind}.`
   }
 
+  // sessions.js owns the terminals region and listens for `leg:sessions`.
+  // `baton:sessions` is the old name, still emitted for anything outside this
+  // page that listens for it; nothing in the board may listen for both, because
+  // each listener rebuilds the whole grid.
+  function publishSessions(detail) {
+    window.dispatchEvent(new CustomEvent('leg:sessions', { detail }))
+    window.dispatchEvent(new CustomEvent('baton:sessions', { detail }))
+  }
+
   function connectSse() {
     if (state.es) { try { state.es.close() } catch { /* ignore */ } }
     const request = ++state.sseRequest
@@ -312,9 +321,12 @@
       // nothing between the drop and this hello was replayed: an open detail
       // region is as old as the gap
       scheduleDrawerRefresh()
-      if (data.sessions) window.dispatchEvent(new CustomEvent('leg:sessions', { detail: data.sessions })); window.dispatchEvent(new CustomEvent('baton:sessions', { detail: data.sessions }));
+      if (data.sessions) publishSessions(data.sessions)
     })
-    es.addEventListener('sessions', (e) => { if (state.es === es && request === state.sseRequest) window.dispatchEvent(new CustomEvent('leg:sessions', { detail: JSON.parse(e.data) })); window.dispatchEvent(new CustomEvent('baton:sessions', { detail: JSON.parse(e.data) })); })
+    // one parse, one publish, and both inside the staleness guard: the missing
+    // braces meant a superseded EventSource still drove a full rebuild, and the
+    // payload (a quarter of a megabyte) was parsed twice to do it
+    es.addEventListener('sessions', (e) => { if (state.es === es && request === state.sseRequest) publishSessions(JSON.parse(e.data)) })
     es.addEventListener('card', (e) => { if (state.es === es && request === state.sseRequest) upsertCard(JSON.parse(e.data)) })
     es.addEventListener('removed', (e) => { if (state.es === es && request === state.sseRequest) dropCard(JSON.parse(e.data).card_id) })
     es.addEventListener('event', (e) => { if (state.es === es && request === state.sseRequest) onLedgerEvent(JSON.parse(e.data)) })
@@ -1042,7 +1054,7 @@
     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 "Baton tries claude, then agy, then claude", a fallback that cannot
+    // 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)