@ucsandman/legcli 0.8.0 → 0.10.0

package/src/hook.mjs

@@ -1,49 +1,49 @@
-#!/usr/bin/env node
-// hook — the process Claude Code runs for a Baton session's hooks and status
-// line (wired by src/taps/claude.mjs through `--settings`). Reads the JSON
-// payload on stdin, updates the session record, exits 0 always: a broken hook
-// must never stall the user's session.
-//   node hook.mjs claude-hook --session <id>
-//   node hook.mjs claude-statusline --session <id>
-// The status line entry records rate_limits when a Claude Code build runs it
-// (2.1.268 does not; see src/taps/claude-usage.mjs) and prints one Baton line.
-import { appendFileSync } from 'node:fs'
-import { join } from 'node:path'
-import { handleHook, handleStatusline } from './taps/claude.mjs'
-import { sessionDir } from './sessions.mjs'
-import { captureLive } from './live-capture.mjs'
-
-function readStdin() {
-  return new Promise((resolve) => {
-    let d = ''
-    const t = setTimeout(() => resolve(d), 4000)
-    process.stdin.setEncoding('utf8')
-    process.stdin.on('data', (c) => { d += c })
-    process.stdin.on('end', () => { clearTimeout(t); resolve(d) })
-    process.stdin.on('error', () => { clearTimeout(t); resolve(d) })
-  })
-}
-
-const [kind, ...rest] = process.argv.slice(2)
-const i = rest.indexOf('--session')
-const sessionId = i !== -1 ? rest[i + 1] : null
-
-try {
-  const raw = await readStdin()
-  let payload = {}
-  try { payload = JSON.parse(raw) } catch {}
-  if (!sessionId) process.exit(0)
-  if (kind === 'claude-hook') {
-    const line = handleHook(sessionId, payload)
-    try { appendFileSync(join(sessionDir(sessionId), 'hook.log'), `${new Date().toISOString()} ${payload.hook_event_name ?? '?'} ${line}\n`) } catch {}
-    // the first real StopFailure per error kind is kept as evidence (never a simulated one)
-    if (payload.hook_event_name === 'StopFailure' && payload.error) {
-      try { captureLive('claude', String(payload.error), payload, { sessionId }) } catch {}
-    }
-  } else if (kind === 'claude-statusline') {
-    const { text } = handleStatusline(sessionId, payload)
-    try { appendFileSync(join(sessionDir(sessionId), 'hook.log'), `${new Date().toISOString()} statusline rate_limits=${JSON.stringify(payload.rate_limits ?? null)}\n`) } catch {}
-    process.stdout.write(text + '\n')
-  }
-} catch {}
-process.exit(0)
+#!/usr/bin/env node
+// hook — the process Claude Code runs for a Leg session's hooks and status
+// line (wired by src/taps/claude.mjs through `--settings`). Reads the JSON
+// payload on stdin, updates the session record, exits 0 always: a broken hook
+// must never stall the user's session.
+//   node hook.mjs claude-hook --session <id>
+//   node hook.mjs claude-statusline --session <id>
+// The status line entry records rate_limits when a Claude Code build runs it
+// (2.1.268 does not; see src/taps/claude-usage.mjs) and prints one Leg line.
+import { appendFileSync } from 'node:fs'
+import { join } from 'node:path'
+import { handleHook, handleStatusline } from './taps/claude.mjs'
+import { sessionDir } from './sessions.mjs'
+import { captureLive } from './live-capture.mjs'
+
+function readStdin() {
+  return new Promise((resolve) => {
+    let d = ''
+    const t = setTimeout(() => resolve(d), 4000)
+    process.stdin.setEncoding('utf8')
+    process.stdin.on('data', (c) => { d += c })
+    process.stdin.on('end', () => { clearTimeout(t); resolve(d) })
+    process.stdin.on('error', () => { clearTimeout(t); resolve(d) })
+  })
+}
+
+const [kind, ...rest] = process.argv.slice(2)
+const i = rest.indexOf('--session')
+const sessionId = i !== -1 ? rest[i + 1] : null
+
+try {
+  const raw = await readStdin()
+  let payload = {}
+  try { payload = JSON.parse(raw) } catch {}
+  if (!sessionId) process.exit(0)
+  if (kind === 'claude-hook') {
+    const line = handleHook(sessionId, payload)
+    try { appendFileSync(join(sessionDir(sessionId), 'hook.log'), `${new Date().toISOString()} ${payload.hook_event_name ?? '?'} ${line}\n`) } catch {}
+    // the first real StopFailure per error kind is kept as evidence (never a simulated one)
+    if (payload.hook_event_name === 'StopFailure' && payload.error) {
+      try { captureLive('claude', String(payload.error), payload, { sessionId }) } catch {}
+    }
+  } else if (kind === 'claude-statusline') {
+    const { text } = handleStatusline(sessionId, payload)
+    try { appendFileSync(join(sessionDir(sessionId), 'hook.log'), `${new Date().toISOString()} statusline rate_limits=${JSON.stringify(payload.rate_limits ?? null)}\n`) } catch {}
+    process.stdout.write(text + '\n')
+  }
+} catch {}
+process.exit(0)

package/src/land.mjs

@@ -213,18 +213,16 @@ export async function applyLandFix(sessionId, action, opts = {}) {
   if (action === 'commit') {
     git(wt, ['add', '-A'])
     const verify = (process.env.LEG_COMMIT_VERIFY || process.env.BATON_COMMIT_VERIFY) === '1' ? [] : ['--no-verify']
-    const msg = opts.message || 'baton: save work before landing'
-    const r = git(wt, ['-c', 'user.email=baton@localhost', '-c', 'user.name=baton', 'commit', '-q', ...verify, '-m', msg])
+    const msg = opts.message || 'leg: save work before landing'
+    const r = git(wt, ['-c', 'user.email=leg@localhost', '-c', 'user.name=leg', 'commit', '-q', ...verify, '-m', msg])
     if (!r.ok) throw new Error(`git commit failed: ${r.err || r.out}`)
-    clearCanLandCache()
     appendEvent(sessionId, { type: 'fix_applied', by: opts.by || 'local', summary: 'committed uncommitted work in worktree' })
     return { ok: true, action: 'commit' }
   }
 
   if (action === 'stash') {
-    const r = git(wt, ['stash', '-u', '-m', 'baton: stash before landing'])
+    const r = git(wt, ['stash', '-u', '-m', 'leg: stash before landing'])
     if (!r.ok) throw new Error(`git stash failed: ${r.err || r.out}`)
-    clearCanLandCache()
     appendEvent(sessionId, { type: 'fix_applied', by: opts.by || 'local', summary: 'stashed uncommitted changes in worktree' })
     return { ok: true, action: 'stash' }
   }
@@ -232,7 +230,6 @@ export async function applyLandFix(sessionId, action, opts = {}) {
   if (action === 'rebase_now') {
     const base = s.worktree?.base || 'main'
     const r = git(wt, ['rebase', base])
-    clearCanLandCache()
     appendEvent(sessionId, { type: 'fix_applied', by: opts.by || 'local', summary: `started rebase onto ${base} in worktree` })
     return { ok: r.ok, action: 'rebase_now', detail: r.out || r.err }
   }
@@ -244,10 +241,9 @@ export async function applyLandFix(sessionId, action, opts = {}) {
   if (action === 'commit_directly') {
     git(wt, ['add', '-A'])
     const verify = (process.env.LEG_COMMIT_VERIFY || process.env.BATON_COMMIT_VERIFY) === '1' ? [] : ['--no-verify']
-    const msg = opts.message || `baton: commit directly on ${s.branch || s.worktree?.base || 'main'}`
-    const r = git(wt, ['-c', 'user.email=baton@localhost', '-c', 'user.name=baton', 'commit', '-q', ...verify, '-m', msg])
+    const msg = opts.message || `leg: commit directly on ${s.branch || s.worktree?.base || 'main'}`
+    const r = git(wt, ['-c', 'user.email=leg@localhost', '-c', 'user.name=leg', 'commit', '-q', ...verify, '-m', msg])
     if (!r.ok) throw new Error(`git commit failed: ${r.err || r.out}`)
-    clearCanLandCache()
     appendEvent(sessionId, { type: 'fix_applied', by: opts.by || 'local', summary: `committed directly on ${s.branch || 'main'}` })
     return { ok: true, action: 'commit_directly' }
   }
@@ -256,13 +252,6 @@ export async function applyLandFix(sessionId, action, opts = {}) {
 }
 
 // ---- canLand: The Guarded State Machine ----
-const canLandCache = new Map()
-
-export function clearCanLandCache(key) {
-  if (key) canLandCache.delete(key)
-  else canLandCache.clear()
-}
-
 export function canLand(worktreeId, opts = {}) {
   const ctx = resolveWorktreeContext(worktreeId)
   if (!ctx) {
@@ -301,16 +290,6 @@ export function canLand(worktreeId, opts = {}) {
     }
   }
 
-  const cacheKey = session?.session_id ? `sess:${session.session_id}` : `path:${path}`
-  if (!opts.fresh && !opts.testResult && !opts.ignoreRunning && !opts.ignoreInFlight && !opts.ignoreTargetActive) {
-    const hit = canLandCache.get(cacheKey)
-    if (hit && Date.now() - hit.ts < (opts.ttlMs ?? 10000)) {
-      if (!session || hit.sessionStatus === session.status) {
-        return hit.result
-      }
-    }
-  }
-
   // Guard 3: Worktree is sitting on target branch itself (e.g. working directly on main)
   if (branch === base) {
     blockers.push({
@@ -427,14 +406,10 @@ export function canLand(worktreeId, opts = {}) {
     })
   }
 
-  const res = {
+  return {
     ok: blockers.length === 0,
     blockers,
   }
-  if (!opts.testResult && !opts.ignoreRunning && !opts.ignoreInFlight && !opts.ignoreTargetActive) {
-    canLandCache.set(cacheKey, { ts: Date.now(), result: res, sessionStatus: session?.status })
-  }
-  return res
 }
 
 // Why this session cannot land right now, or null.
@@ -527,7 +502,6 @@ export async function prepareLanding(worktreeId) {
     try { if (existsSync(scratchDir)) rmSync(scratchDir, { recursive: true, force: true }) } catch {}
     try { git(repo, ['worktree', 'prune']) } catch {}
     releaseTargetLock(repo, base, lock.token)
-    clearCanLandCache()
   }
 }
 
@@ -548,7 +522,7 @@ export async function landSession(session, { by = 'local', autoCommit = true, ig
   if (autoCommit && existsSync(path)) {
     ensureExcludeEntries(repo)
     const task = String(session.task ?? 'terminal session').split('\n')[0].slice(0, 60)
-    commitWorktree(path, `baton: ${session.agent ?? 'agent'} ${id.split('-').pop()}: ${task}`)
+    commitWorktree(path, `leg: ${session.agent ?? 'agent'} ${id.split('-').pop()}: ${task}`)
   }
 
   const cl = canLand(session, { ignoreInFlight: true, ignoreRunning, ignoreTargetActive })
@@ -722,7 +696,6 @@ export async function landSession(session, { by = 'local', autoCommit = true, ig
     try { git(repo, ['worktree', 'prune']) } catch {}
     if (lock) releaseTargetLock(repo, base, lock.token)
     inFlight.delete(id)
-    clearCanLandCache()
     drainLandingQueue(repo, base).catch(() => {})
   }
 }
@@ -730,7 +703,6 @@ export async function landSession(session, { by = 'local', autoCommit = true, ig
 // Removing a finished session takes its worktree and branch with it only when
 // nothing is lost: a clean worktree whose branch is already in its base.
 export function pruneSessionWorktree(s) {
-  clearCanLandCache()
   const wt = s.worktree
   if (!wt || !existsSync(wt.path)) return { removed: false, reason: 'no worktree on disk' }
   const status = git(wt.path, ['status', '--porcelain'])

package/src/launcher.mjs

@@ -16,7 +16,19 @@ import { schedulerStatus, MAX_CONCURRENT } from './scheduler.mjs'
 import { enabledSyncs } from './sync/index.mjs'
 
 const SRC = dirname(fileURLToPath(import.meta.url))
-const SERVER = process.env.LEG_SERVER_SCRIPT || process.env.BATON_SERVER_SCRIPT || join(SRC, 'server.mjs')
+function resolveServer() {
+  if (process.env.LEG_SERVER_SCRIPT || process.env.BATON_SERVER_SCRIPT) {
+    return process.env.LEG_SERVER_SCRIPT || process.env.BATON_SERVER_SCRIPT
+  }
+  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 VERSION = JSON.parse(readFileSync(join(SRC, '..', 'package.json'), 'utf8')).version
 const HEALTH_TIMEOUT_MS = Number(process.env.LEG_HEALTH_TIMEOUT_MS || process.env.BATON_HEALTH_TIMEOUT_MS || 20000)
 
@@ -74,13 +86,13 @@ export function printPreflight({ rows }) {
 
 export function plannedProcesses({ port = Number(process.env.LEG_PORT || process.env.BATON_PORT || 4747), bind = process.env.LEG_BIND || process.env.BATON_BIND || '127.0.0.1' } = {}) {
   const procs = [{
-    prefix: 'server', bin: process.execPath, argv: [SERVER], env: { BATON_PORT: String(port), BATON_BIND: bind },
+    prefix: 'server', bin: process.execPath, argv: [SERVER], env: { LEG_PORT: String(port), LEG_BIND: bind, BATON_PORT: String(port), BATON_BIND: bind },
     note: 'board + API + scheduler + merge queue',
   }]
   const on = enabledSyncs()
   const syncs = [
-    { prefix: 'sync:workboard', enabled: on.includes('workboard'), note: 'OpenClaw Workboard mirror (BATON_SYNC_WORKBOARD=1); runs inside the ledger, no extra process' },
-    { prefix: 'sync:dashclaw', enabled: on.includes('dashclaw'), note: 'DashClaw action recording (BATON_SYNC_DASHCLAW=1 + DASHCLAW_URL + DASHCLAW_API_KEY); runs inside the ledger' },
+    { prefix: 'sync:workboard', enabled: on.includes('workboard'), note: 'OpenClaw Workboard mirror (LEG_SYNC_WORKBOARD=1); runs inside the ledger, no extra process' },
+    { prefix: 'sync:dashclaw', enabled: on.includes('dashclaw'), note: 'DashClaw action recording (LEG_SYNC_DASHCLAW=1 + DASHCLAW_URL + DASHCLAW_API_KEY); runs inside the ledger' },
   ]
   return { procs, syncs }
 }
@@ -160,21 +172,21 @@ function killActiveAgents() {
 }
 
 export async function up({ dry = false, open = true, port = Number(process.env.LEG_PORT || process.env.BATON_PORT || 4747), bind = process.env.LEG_BIND || process.env.BATON_BIND || '127.0.0.1' } = {}) {
-  out('baton', `baton ${VERSION} — home ${home()}`)
+  out('leg', `leg ${VERSION} — home ${home()}`)
   const pf = await preflight()
   printPreflight(pf)
-  if (pf.adapters_present === 0) out('baton', 'no real coding-agent CLI found; fake adapters still work for the demo', process.stderr)
+  if (pf.adapters_present === 0) out('leg', 'no real coding-agent CLI found; fake adapters still work for the demo', process.stderr)
   const plan = plannedProcesses({ port, bind })
-  for (const s of plan.syncs) out('baton', `${s.prefix}: ${s.enabled ? 'on' : 'off'} (${s.note})`)
+  for (const s of plan.syncs) out('leg', `${s.prefix}: ${s.enabled ? 'on' : 'off'} (${s.note})`)
   if (dry) {
-    out('baton', 'dry run: nothing spawned. Would run:')
-    for (const p of plan.procs) out('baton', `${p.prefix}: ${JSON.stringify([p.bin, ...p.argv])} env ${JSON.stringify(p.env)}`)
-    out('baton', `then poll http://${bind}:${port}/api/health, ${open ? 'open the board' : 'not open the board'}, write ${pidfile()}`)
+    out('leg', 'dry run: nothing spawned. Would run:')
+    for (const p of plan.procs) out('leg', `${p.prefix}: ${JSON.stringify([p.bin, ...p.argv])} env ${JSON.stringify(p.env)}`)
+    out('leg', `then poll http://${bind}:${port}/api/health, ${open ? 'open the board' : 'not open the board'}, write ${pidfile()}`)
     return 0
   }
   const existing = readPidfile()
   if (existing && existing.pid !== process.pid && await boardAlive(existing)) {
-    out('baton', `already running (pid ${existing.pid}, port ${existing.port}); use \`baton down\` first`, process.stderr)
+    out('leg', `already running (pid ${existing.pid}, port ${existing.port}); use \`leg down\` first`, process.stderr)
     return 1
   }
   if (existing) { try { rmSync(pidfile(), { force: true }) } catch {} }
@@ -197,34 +209,34 @@ export async function up({ dry = false, open = true, port = Number(process.env.L
     await new Promise((r) => setTimeout(r, 250))
   }
   if (!ok) {
-    out('baton', `server not healthy after ${Math.round((Date.now() - t0) / 1000)} s${exited !== null ? ` (exited ${exited})` : ''}; last lines:`, process.stderr)
+    out('leg', `server not healthy after ${Math.round((Date.now() - t0) / 1000)} s${exited !== null ? ` (exited ${exited})` : ''}; last lines:`, process.stderr)
     for (const l of lastLines) out(p.prefix, l, process.stderr)
     killTree(child.pid)
     return 1
   }
   const url = `http://${bind === '0.0.0.0' ? '127.0.0.1' : bind}:${actualPort}`
   writeFileSync(pidfile(), JSON.stringify({ pid: process.pid, port: actualPort, bind, children: [child.pid], started_at: new Date().toISOString() }, null, 2) + '\n')
-  out('baton', `ready ${url}  (scheduler max ${MAX_CONCURRENT}, ${ok.cards} card${ok.cards === 1 ? '' : 's'})`)
-  if (open) out('baton', openBoard(url) ? `opened ${url}` : `could not open a browser; visit ${url}`)
-  out('baton', 'Ctrl-C stops everything')
+  out('leg', `ready ${url}  (scheduler max ${MAX_CONCURRENT}, ${ok.cards} card${ok.cards === 1 ? '' : 's'})`)
+  if (open) out('leg', openBoard(url) ? `opened ${url}` : `could not open a browser; visit ${url}`)
+  out('leg', 'Ctrl-C stops everything')
 
   return await new Promise((resolvePromise) => {
     let stopping = false
     const stop = (why) => {
       if (stopping) return
       stopping = true
-      out('baton', `stopping (${why})`)
+      out('leg', `stopping (${why})`)
       const agents = killActiveAgents()
-      if (agents) out('baton', `killed ${agents} running agent/supervisor process(es)`)
+      if (agents) out('leg', `killed ${agents} running agent/supervisor process(es)`)
       killTree(child.pid)
       try { rmSync(pidfile(), { force: true }) } catch {}
-      out('baton', 'stopped')
+      out('leg', 'stopped')
       resolvePromise(0)
     }
     process.on('SIGINT', () => stop('SIGINT'))
     process.on('SIGTERM', () => stop('SIGTERM'))
     process.on('SIGBREAK', () => stop('SIGBREAK'))
-    child.on('exit', (code) => { if (!stopping) { out('baton', `server exited ${code}`, process.stderr); try { rmSync(pidfile(), { force: true }) } catch {} resolvePromise(code === 0 ? 0 : 1) } })
+    child.on('exit', (code) => { if (!stopping) { out('leg', `server exited ${code}`, process.stderr); try { rmSync(pidfile(), { force: true }) } catch {} resolvePromise(code === 0 ? 0 : 1) } })
   })
 }
 
@@ -241,10 +253,10 @@ export async function stopBoard() {
 
 export async function down() {
   const pf = readPidfile()
-  if (!pf) { out('baton', 'not running'); return 0 }
+  if (!pf) { out('leg', 'not running'); return 0 }
   const agents = killActiveAgents()
   const board = await stopBoard()
-  out('baton', `stopped (pid ${pf.pid}, port ${pf.port}${agents ? `, ${agents} agent process(es) killed` : ''}${board.stale ? ', stale pidfile' : ''})`)
+  out('leg', `stopped (pid ${pf.pid}, port ${pf.port}${agents ? `, ${agents} agent process(es) killed` : ''}${board.stale ? ', stale pidfile' : ''})`)
   return 0
 }
 
@@ -256,14 +268,14 @@ export async function status() {
   const by = (key) => Object.entries(cards.reduce((m, c) => { m[c[key]] = (m[c[key]] ?? 0) + 1; return m }, {})).map(([k, v]) => `${k}=${v}`).join(' ') || '(none)'
   if (running) {
     const up = Math.round((Date.now() - Date.parse(pf.started_at)) / 1000)
-    out('baton', `running  pid ${pf.pid}  port ${pf.port}  up ${Math.floor(up / 60)}m${up % 60}s  http://127.0.0.1:${pf.port}`)
+    out('leg', `running  pid ${pf.pid}  port ${pf.port}  up ${Math.floor(up / 60)}m${up % 60}s  http://127.0.0.1:${pf.port}`)
   } else {
-    out('baton', pf ? `stopped (pid ${pf.pid} is not answering on port ${pf.port}; cleared the stale pidfile)` : 'stopped')
+    out('leg', pf ? `stopped (pid ${pf.pid} is not answering on port ${pf.port}; cleared the stale pidfile)` : 'stopped')
   }
   const s = schedulerStatus()
-  out('baton', `scheduler ${s.running ? `running (pid ${s.pid})` : 'stopped'}  max concurrent ${MAX_CONCURRENT}`)
-  out('baton', `cards ${cards.length}  by status: ${by('status')}`)
-  out('baton', `by station: ${by('station')}`)
+  out('leg', `scheduler ${s.running ? `running (pid ${s.pid})` : 'stopped'}  max concurrent ${MAX_CONCURRENT}`)
+  out('leg', `cards ${cards.length}  by status: ${by('status')}`)
+  out('leg', `by station: ${by('station')}`)
   return running ? 0 : 3
 }
 

package/src/ledger.mjs

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 // Ported 2026-09-10 from private ucsandman team tooling; see NOTICE and docs/REUSE.md.
-// ledger — the ONLY writer of Baton's card ledger files under $BATON_HOME/cards/<id>/.
+// ledger — the ONLY writer of Leg's card ledger files under $LEG_HOME/cards/<id>/.
 // Subcommands: create | append | update | sync. Every event carries a validated
 // actor, the card id, the station and the leg, and lands in that actor's own
 // events-<actor-key>.jsonl. Importable: readEvents, parseActor, actorKey.
@@ -17,16 +17,16 @@ export const EVENT_TYPES = ['card_created', 'leg_started', 'leg_progress', 'leg_
   'limit_detected', 'handoff_written', 'leg_resumed', 'station_done', 'bounced', 'landed',
   'land_warning', 'land_retry', 'blocked_by', 'scheduler_started', 'scheduler_stopped',
   'approval_needed', 'approved', 'reassigned', 'paused', 'resumed', 'killed', 'done',
-  'failed', 'error', 'status']
+  'failed', 'error', 'status', 'harness', 'harness_blocked']
 export const STATUSES = ['backlog', 'queued', 'running', 'handing_off', 'waiting_human',
   'needs_approval', 'paused', 'done', 'failed', 'killed']
 const CLOSED = ['done', 'failed', 'killed']
 // card.json keys `update --patch` may set (everything else goes through a named flag)
 export const PATCHABLE = ['pipeline', 'leases', 'land_attempts', 'land_mode', 'test_command', 'title', 'trunk',
-  'bounce_reason', 'kill_requested', 'worktree', 'next_leg', 'handoff_outcome', 'resume_from_bundle', 'failure', 'last_bundle', 'pr_url']
+  'bounce_reason', 'kill_requested', 'worktree', 'next_leg', 'handoff_outcome', 'resume_from_bundle', 'failure', 'last_bundle', 'pr_url', 'harness']
 const NAME_RE = /^[a-z0-9][a-z0-9._-]{0,39}$/i
 
-export const ROOT = process.env.BATON_HOME || join(homedir(), '.baton')
+export const ROOT = process.env.LEG_HOME || process.env.BATON_HOME || (existsSync(join(homedir(), '.leg')) ? join(homedir(), '.leg') : existsSync(join(homedir(), '.baton')) ? join(homedir(), '.baton') : join(homedir(), '.leg'))
 
 function die(code, msg) {
   process.stderr.write(msg + '\n')
@@ -53,7 +53,7 @@ function need(args, key, allowed) {
   return v
 }
 
-// Actor: who wrote the event. {type:'agent', adapter, model?} | {type:'human', id} | {type:'baton'}.
+// Actor: who wrote the event. {type:'agent', adapter, model?} | {type:'human', id} | {type:'leg'} | {type:'baton'} (legacy).
 // Returns the normalized actor or null when the shape is wrong.
 export function parseActor(raw) {
   let a = raw
@@ -156,7 +156,7 @@ async function syncNotify(kind, ev, card) {
       kind, ev, card, home: ROOT,
       report: (summary) => {
         if (!id) return
-        appendEvent(id, { ts: now(), card_id: id, actor: { type: 'baton' }, station: card?.station ?? '-', leg: card?.leg ?? 0, type: 'status', summary })
+        appendEvent(id, { ts: now(), card_id: id, actor: { type: 'leg' }, station: card?.station ?? '-', leg: card?.leg ?? 0, type: 'status', summary })
       },
     })
   } catch {}

package/src/license.mjs

@@ -1,34 +1,35 @@
 // license — the paid-product gate. A license key is a signed, self-contained
-// token that Baton checks offline with the public key embedded below; the
+// token that Leg checks offline with the public key embedded below; the
 // private key never leaves the seller's machine. Two plans:
 //
 //   personal  one-time purchase; every release dated on or before the key's
 //             updates_until activates, later releases refuse the key but the
 //             installed one keeps working (the Sublime Text shape)
 //   team      per-seat subscription; the key carries an expiry a few days past
-//             the billing period, `baton license refresh` fetches a renewed one
+//             the billing period, `leg license refresh` fetches a renewed one
 //
-// There is no trial. Baton pays off in the moment a limit lands mid-flow, which
+// There is no trial. Leg pays off in the moment a limit lands mid-flow, which
 // is not a thing a fortnight of evaluation reliably contains; the risk reversal
 // is a 30-day money-back guarantee instead, which costs no code and no expiry
-// machinery. Key shape: BATON-<base64url payload>.<base64url signature> where
-// the signature is Ed25519 over the payload bytes exactly as encoded.
+// machinery. Key shape: LEG-<base64url payload>.<base64url signature> (legacy
+// BATON- prefix still accepted) where the signature is Ed25519 over the payload
+// bytes exactly as encoded.
 import { createPublicKey, createPrivateKey, verify as cryptoVerify, sign as cryptoSign, createHash } from 'node:crypto'
 import { readFileSync, writeFileSync, existsSync, mkdirSync, unlinkSync, chmodSync } from 'node:fs'
 import { join } from 'node:path'
 import { home } from './store.mjs'
 
 export const PUBLIC_KEY_B64 = 'MCowBQYDK2VwAyEAIpVQymHHJAkIrZHv0u4o0bgfFmtW3Crm7uMwYHP53X8='
-// The suite has to exercise the gate itself — `baton share on` refusing a
-// Personal key, `baton <agent>` refusing nothing at all — and it cannot sign a
+// The suite has to exercise the gate itself — `leg share on` refusing a
+// Personal key, `leg <agent>` refusing nothing at all — and it cannot sign a
 // key for the real public key, which is the point of the real public key. This
 // env seam lets a spawned CLI verify against a throwaway pair. It weakens
-// nothing: Baton ships as readable JavaScript, so anyone who would set this
+// nothing: Leg ships as readable JavaScript, so anyone who would set this
 // could edit the constant above instead.
 const ACTIVE_PUBLIC_KEY = process.env.LEG_PUBLIC_KEY_B64 || process.env.BATON_PUBLIC_KEY_B64 || PUBLIC_KEY_B64
 // The date this release was cut. A personal key activates when this is on or
 // before its updates_until. Bumped with every published version.
-export const RELEASE_DATE = '2026-09-15'
+export const RELEASE_DATE = '2026-09-16'
 export const GUARANTEE_DAYS = 30
 export const SITE = process.env.LEG_SITE || process.env.BATON_SITE || 'https://legcli.com'
 export const BUY_URL = `${SITE}/#pricing`

package/src/live-capture.mjs

@@ -3,7 +3,7 @@
 // keep the payload with secrets scrubbed, so the docs rows that say
 // "docs-only" can become "observed-live" with evidence. One file per
 // (agent, signal); a later arrival never overwrites the first. A payload a
-// `baton sessions simulate-limit` produced is marked and never captured.
+// `leg sessions simulate-limit` produced is marked and never captured.
 // Where: BATON_LIVE_DIR, else this checkout's fixtures/live/ when it exists
 // (a dev clone), else <BATON_HOME>/live/. In a dev clone the matching docs
 // rows are flipped in the same call (scripts/live-limits.mjs).

package/src/mergequeue.mjs

@@ -1,6 +1,6 @@
 // mergequeue — the land station. One land at a time per repo root, FIFO: the
 // queue key is the canonical root (two spellings of one path are one queue) and
-// the turn itself is a file lock under BATON_HOME, so a `baton card run` CLI
+// the turn itself is a file lock under LEG_HOME, so a `leg card run` CLI
 // and the board server cannot land into one checkout at the same time.
 // land(card, worktree):
 //   1. root must be on <trunk> and clean, else bounce `dirty-trunk` (root untouched)
@@ -57,7 +57,7 @@ export function rootState(repo, trunk) {
 }
 
 // Commit the agents' work so the branch can be rebased and merged. The commit
-// skips git hooks (--no-verify): the repo's test command is Baton's gate, and
+// skips git hooks (--no-verify): the repo's test command is Leg's gate, and
 // interactive commit hooks (linters, wire-dark style checks) belong to humans
 // typing commits. BATON_COMMIT_VERIFY=1 runs them anyway.
 export function commitWorktree(worktree, message) {
@@ -65,7 +65,7 @@ export function commitWorktree(worktree, message) {
   if (!dirty.length) return { committed: false }
   git(worktree, ['add', '-A'])
   const verify = (process.env.LEG_COMMIT_VERIFY || process.env.BATON_COMMIT_VERIFY) === '1' ? [] : ['--no-verify']
-  git(worktree, ['-c', 'user.email=baton@localhost', '-c', 'user.name=baton', 'commit', '-q', ...verify, '-m', message])
+  git(worktree, ['-c', 'user.email=leg@localhost', '-c', 'user.name=leg', 'commit', '-q', ...verify, '-m', message])
   return { committed: true, files: dirty.length }
 }
 
@@ -147,7 +147,7 @@ async function landNow(card, worktree, { onWarning = () => {}, allowDirtyRoot =
   if (checkedOut !== branch) return bounce('worktree-branch', `worktree is on ${checkedOut}, not ${branch}; switch it back before landing`)
 
   const busy = operationInProgress(worktree)
-  if (busy) return bounce('worktree-busy', `a ${busy.replace(/-/g, ' ')} is already in progress in ${worktree}; finish or abort it there before landing (Baton will not touch a rebase it did not start)`)
+  if (busy) return bounce('worktree-busy', `a ${busy.replace(/-/g, ' ')} is already in progress in ${worktree}; finish or abort it there before landing (Leg will not touch a rebase it did not start)`)
 
   const root = rootState(repo, trunk)
   if (!root.onTrunk) return bounce('dirty-trunk', `repo root is on ${root.branch}, not ${trunk}; check out ${trunk} and retry`)
@@ -155,7 +155,7 @@ async function landNow(card, worktree, { onWarning = () => {}, allowDirtyRoot =
   // nature; git's own fast-forward still refuses to overwrite a local change
   if (root.dirty.length && !allowDirtyRoot) return bounce('dirty-trunk', `repo root has ${root.dirty.length} uncommitted change(s): ${root.dirty.slice(0, 10).join(', ')}`)
 
-  const committed = commitWorktree(worktree, `baton: ${card.title ?? card.card_id}`)
+  const committed = commitWorktree(worktree, `leg: ${card.title ?? card.card_id}`)
   const preSha = git(worktree, ['rev-parse', 'HEAD']).stdout.trim()
   const trunkBefore = trunkHead(repo)
 

package/src/orchestrator.mjs

@@ -18,6 +18,7 @@ import {
   RUNNER, BATON_ACTOR, readCard, ledgerAppend, ledgerUpdate, cardDir, sleep,
 } from './store.mjs'
 import { scrub, updateRun } from './runner.mjs'
+import { prepareHarnessForHandoff, harnessLine } from './harness/index.mjs'
 import * as agentStation from './stations/agent.mjs'
 import * as testStation from './stations/test.mjs'
 import * as humanStation from './stations/human.mjs'
@@ -26,13 +27,16 @@ import * as humanStation from './stations/human.mjs'
 // the merge queue). Each handler gets the orchestrator's helpers as `ops`.
 const KIND_HANDLERS = { agent: agentStation, test: testStation, human: humanStation }
 
-const POLL_MS = Number(process.env.BATON_POLL_MS || 2000)
+const POLL_MS = Number(process.env.LEG_POLL_MS || process.env.BATON_POLL_MS || 2000)
 const WAITING = ['done', 'failed', 'killed', 'paused', 'waiting_human', 'needs_approval']
 // Patchable card keys the chain machine may change; everything else is a
 // named ledger flag.
 const PATCH_KEYS = ['pipeline', 'leases', 'land_attempts', 'bounce_reason', 'kill_requested', 'next_leg', 'handoff_outcome', 'resume_from_bundle', 'failure', 'pr_url']
 
-const log = (msg) => { if (process.env.BATON_QUIET !== '1') process.stderr.write(`[baton] ${msg}\n`) }
+const log = (msg) => {
+  const quiet = (process.env.LEG_QUIET === '0' || process.env.BATON_QUIET === '0') ? false : (process.env.LEG_QUIET === '1' || process.env.BATON_QUIET === '1')
+  if (!quiet) process.stderr.write(`[leg] ${msg}\n`)
+}
 
 // Persist a chain transition: card fields via ledger update, events via append.
 export function apply(id, before, result, actor = BATON_ACTOR) {
@@ -70,7 +74,7 @@ function latestRun(id) {
 }
 
 // A run whose verdict no orchestrator has consumed: the latest run has no
-// settled_at. Happens after `baton down` (agents killed, the supervisor wrote
+// settled_at. Happens after `leg down` (agents killed, the supervisor wrote
 // its verdict, the server that would apply it was already gone) or a crashed
 // server. runCard re-attaches to it instead of launching a fresh leg.
 export function unsettledRun(id) {
@@ -176,7 +180,7 @@ async function waitForRun(id, n, { pollMs = POLL_MS } = {}) {
 function changedFiles(worktree) {
   const r = spawnSync('git', ['status', '--porcelain'], { cwd: worktree, windowsHide: true, encoding: 'utf8', env: { ...process.env, MSYS_NO_PATHCONV: '1' } })
   if (r.status !== 0) return []
-  return r.stdout.split(/\r?\n/).filter(Boolean).map((l) => l.slice(3).trim()).filter((f) => f && !f.startsWith('.baton'))
+  return r.stdout.split(/\r?\n/).filter(Boolean).map((l) => l.slice(3).trim()).filter((f) => f && !f.startsWith('.baton') && !f.startsWith('.leg'))
 }
 
 function diffStat(worktree) {
@@ -197,6 +201,26 @@ async function runLeg(card, station, worktree) {
   const prompt = legPrompt({ contractText, resumeText })
   const promptFile = join(cardDir(card.card_id), `prompt-${station.name}-leg${card.leg}.txt`)
   writeFileSync(promptFile, prompt)
+  // The portable harness for the adapter about to run (src/harness/index.mjs):
+  // nothing when the feature is off; otherwise the card keeps the outcome and
+  // the ledger says what transferred. Under the strict policy a destination
+  // that cannot be made safe is not launched: the leg fails as launch_failed,
+  // which never advances the chain, and a human fixes it and reruns.
+  const previous = card.leg > 0 ? station.chain[card.leg - 1]?.adapter ?? null : null
+  let harness
+  try { harness = prepareHarnessForHandoff({ from: previous, to: entry.adapter, sessionId: card.card_id }) } catch (err) { harness = { state: 'error', proceed: true, to: entry.adapter, reason: String(err.message).slice(0, 200), summary: `harness error: ${String(err.message).slice(0, 120)}` } }
+  if (harness.state !== 'off') {
+    // the card keeps the verdict; the full record (components, dropped items,
+    // files, backups) is in $LEG_HOME/harness/history.jsonl, and the ledger's
+    // argv is not the place for it
+    const { state, target, source = null, policy, fingerprint = null, captured_at = null, synced_at = null, summary = null, proceed, reason = null } = harness
+    ledgerUpdate(card.card_id, { patch: { harness: { state, target, source, policy, fingerprint, captured_at, synced_at, summary, proceed, reason, dropped: harness.dropped?.length ?? 0, attention: harness.attention?.length ?? 0 } } })
+    const line = harnessLine(harness)
+    // the ledger refuses a line that looks like a secret by exiting; evidence
+    // about the harness must never be what fails a leg
+    if (line) { try { ledgerAppend(card.card_id, { type: harness.proceed ? 'harness' : 'harness_blocked', station: station.name, leg: card.leg, summary: line, body: [...(harness.attention ?? []).map((a) => `attention ${a.component}: ${a.reason}`), ...(harness.dropped ?? []).map((d) => `dropped ${d.component}: ${d.item}: ${d.reason}`)].join('\n') || undefined }) } catch (err) { log(`harness event not recorded: ${scrub(String(err.message)).slice(0, 160)}`) } }
+    if (!harness.proceed) return { status: 'failed', outcome: 'launch_failed', handoff: true, signal: 'none', reason: `strict harness policy refused ${entry.adapter}: ${harness.reason ?? harness.state}`, run: null, exit_code: null }
+  }
   const args = ['launch', '--card', card.card_id, '--adapter', entry.adapter, '--prompt-file', promptFile, '--cwd', worktree, '--driver-pid', String(process.pid)]
   if (entry.mode) args.push('--mode', entry.mode)
   if (entry.maxTurns) args.push('--max-turns', String(entry.maxTurns))