@ucsandman/legcli 0.8.0 → 0.10.0

package/src/session-detail.mjs

@@ -11,6 +11,7 @@ import { scrub } from './redact.mjs'
 import { transcriptTail as claudeTail } from './taps/claude.mjs'
 import { transcriptTail as codexTail } from './taps/codex.mjs'
 import { resumeVerdict, verdictForBoard } from './resume.mjs'
+import { readHistory } from './harness/index.mjs'
 
 export const MESSAGE_LIMIT = 8
 export const DIFF_MAX_LINES = 400
@@ -41,7 +42,7 @@ export function sessionMessages(session, limit = MESSAGE_LIMIT) {
   if (!path) return []
   const tail = session.agent === 'claude' ? claudeTail(path, limit)
     : session.agent === 'codex' ? codexTail(path, limit)
-      : [] // agy keeps no transcript Baton can read
+      : [] // agy keeps no transcript Leg can read
   return tail.map((m) => ({ role: m.role === 'user' ? 'user' : 'assistant', text: scrub(m.text), ts: m.ts ?? null }))
 }
 
@@ -116,6 +117,18 @@ function resumeFor(session) {
   try { return verdictForBoard(resumeVerdict(root)) } catch { return null }
 }
 
+// The harness the leg now running was given: what the session recorded when
+// the leg started, plus every capture, sync and decision the harness trail
+// holds for this session. Paths in the attention list are local; a guest never
+// reaches the drawer.
+function harnessFor(session) {
+  const h = session.harness ?? null
+  let history = []
+  try { history = readHistory(200).filter((r) => r.session_id === session.session_id).slice(-20) } catch { /* the drawer renders without the trail */ }
+  if (!h && !history.length) return null
+  return { ...(h ?? {}), history }
+}
+
 export function sessionDetail(session) {
   return {
     session_id: session.session_id,
@@ -124,6 +137,7 @@ export function sessionDetail(session) {
     events: readEvents(session.session_id).slice(-EVENT_LIMIT),
     bundle: session.bundle ?? null,
     resume: resumeFor(session),
+    harness: harnessFor(session),
     ts: new Date().toISOString(),
   }
 }

package/src/sessions.mjs

@@ -1,4 +1,4 @@
-// sessions — the store behind `baton claude|codex|agy`. One directory per
+// sessions — the store behind `leg claude|codex|agy`. One directory per
 // interactive terminal session under $BATON_HOME/sessions/<id>/:
 //   session.json   the live record the board renders (atomic writes)
 //   events.jsonl   timeline (started, turn, warning, limit, handoff, ended)
@@ -44,7 +44,7 @@ export function listSessions() {
 
 export function isActive(s) { return ACTIVE.includes(s?.status) }
 
-// The checkout this session's files live in: its own worktree when Baton gave
+// The checkout this session's files live in: its own worktree when Leg gave
 // it one (repo stays the main checkout, for grouping and landing), else the repo.
 export function workRoot(s) { return s?.worktree?.path ?? s?.repo ?? s?.cwd ?? null }
 
@@ -58,10 +58,13 @@ export function createSession({ id, agent, account = 'default', cwd, repo = null
     task: null, turns: 0,
     files_touched: [], files_dirty: [], head: null, head_at_start: null,
     limits: null, limit: null, warning: null,
-    bundle: null, handoff: null, chain,
+    bundle: null, handoff: null, chain, checkpoints: [],
     handoff_order: normalizeHandoffOrder(handoffOrder), installed,
     runtime_capabilities: [...new Set(runtimeCapabilities)],
     lineage: { from: null, to: null },
+    // the portable-harness outcome for the leg now running (src/harness/index.mjs);
+    // null until the feature is enabled and a leg has been prepared
+    harness: null,
     exit_code: null,
   }
   mkdirSync(sessionDir(id), { recursive: true })
@@ -82,6 +85,15 @@ export function updateSession(id, patch, { event } = {}) {
     const delta = typeof patch === 'function' ? patch(cur) : patch
     const next = { ...cur, ...delta, updated_at: now() }
     if (delta.limits && cur.limits) next.limits = { ...cur.limits, ...delta.limits }
+    // every agent conversation this session has been: a hand-off overwrites
+    // agent_session_id with the next agent's, and history (src/history) still
+    // needs to know the earlier legs were this session's too
+    if (delta.agent_session_id && delta.agent_session_id !== cur.agent_session_id) {
+      const seen = cur.agent_sessions ?? []
+      if (!seen.some((x) => x.agent === next.agent && x.agent_session_id === delta.agent_session_id)) {
+        next.agent_sessions = [...seen, { agent: next.agent, agent_session_id: delta.agent_session_id, transcript_path: delta.transcript_path ?? null, at: now() }].slice(-24)
+      }
+    }
     writeJsonAtomic(join(sessionDir(id), 'session.json'), next)
     if (event) appendEvent(id, event)
     return next

package/src/share.mjs

@@ -1,7 +1,7 @@
-// share — optional multiplayer for the board, off until `baton share on`
+// share — optional multiplayer for the board, off until `leg share on`
 // writes $BATON_HOME/share.json. With it on, the board binds the Tailscale or
 // LAN address, every human has a name and their own token (kept as a sha256
-// hash: a token is printed once and `baton share rotate` issues a new one),
+// hash: a token is printed once and `leg share rotate` issues a new one),
 // and every session belongs to the human whose terminal started it
 // (`BATON_PERSON`, else the owner). With it off nothing changes: loopback is
 // open and `BATON_TOKEN` is the only token.

package/src/stations/agent.mjs

@@ -1,4 +1,4 @@
-// Station kind: agent. One chain leg runs here (or, after `baton down` or a
+// Station kind: agent. One chain leg runs here (or, after `leg down` or a
 // crashed server, the orchestrator re-attaches to the run it left behind),
 // the run is settled, and its verdict is applied to the card. `ops` are the
 // orchestrator's helpers; this module never imports the orchestrator.

package/src/sync/dashclaw.mjs

@@ -1,5 +1,5 @@
 // dashclaw sync — records every ledger event as a DashClaw action over native
-// http/https (LESSONS 07-12: no global fetch). Off unless BATON_SYNC_DASHCLAW=1
+// http/https (LESSONS 07-12: no global fetch). Off unless LEG_SYNC_DASHCLAW=1
 // and DASHCLAW_URL + DASHCLAW_API_KEY are set. Field names come from
 // DashClaw's validator (app/lib/validate.js ACTION_RECORD_SCHEMA): agent_id,
 // action_type and declared_goal are required; status is one of running,
@@ -26,11 +26,11 @@ const STATUS_BY_TYPE = {
 
 // One ledger event → one action record (the request body).
 export function actionForEvent(ev, card = null) {
-  const actor = ev.actor ?? { type: 'baton' }
-  const agent = actor.type === 'agent' ? `baton/${actor.adapter}` : actor.type === 'human' ? `baton/human:${actor.id}` : 'baton'
+  const actor = ev.actor ?? { type: 'leg' }
+  const agent = actor.type === 'agent' ? `leg/${actor.adapter}` : actor.type === 'human' ? `leg/human:${actor.id}` : 'leg'
   const body = {
     agent_id: agent,
-    action_type: `baton_${ev.type}`,
+    action_type: `leg_${ev.type}`,
     declared_goal: String(ev.summary ?? ev.type).slice(0, 2000),
     status: STATUS_BY_TYPE[ev.type] ?? 'completed',
     reversible: true,

package/src/synthesis.mjs

@@ -0,0 +1,165 @@
+// synthesis — the agent-maintained judgment record included in the handoff bundle.
+// Spec: Leg Handoff Synthesis Layer — build spec v1
+// File: .leg/SYNTHESIS-<session-id>.md
+import { existsSync, readFileSync, statSync } from 'node:fs'
+import { join } from 'node:path'
+
+export const MAX_SYNTHESIS_BYTES = 4096
+export const TRUNCATED_MARKER = '[synthesis truncated]'
+export const INVALID_HEADER_PREFIX = '[synthesis header invalid, rendering body as-is]'
+export const SYNTHESIS_POINTER_PARAGRAPH = "Read the Synthesis section first if present. Treat 'Ruled out' as settled: do not retry a ruled-out approach unless you have new evidence it was wrong. Start from the top-ranked Next step unless the repo state contradicts it."
+
+export const SYNTHESIS_SECTIONS = [
+  '## Ruled out',
+  '## Decisions',
+  '## Next steps',
+  '## Open questions',
+]
+
+// The synthesis file path for a session in its checkout/worktree root
+export function synthesisFile(cwd, id) {
+  if (!cwd || !id) return null
+  const leg = join(cwd, '.leg', `SYNTHESIS-${id}.md`)
+  const baton = join(cwd, '.baton', `SYNTHESIS-${id}.md`)
+  if (existsSync(leg)) return leg
+  if (existsSync(baton)) return baton
+  if (existsSync(join(cwd, '.baton')) && !existsSync(join(cwd, '.leg'))) return baton
+  return leg
+}
+
+// Safely read the synthesis file; returns null if absent, empty, or unreadable
+export function readSynthesis(cwd, id) {
+  if (!cwd || !id) return null
+  const file = synthesisFile(cwd, id)
+  try {
+    if (!existsSync(file)) return null
+    const text = readFileSync(file, 'utf8')
+    if (!text || !text.trim()) return null
+    return text
+  } catch {
+    return null
+  }
+}
+
+// The standing directive for Leg per-session instructions
+export function synthesisDirective(sessionId = '<session-id>') {
+  return `Maintain .leg/SYNTHESIS-${sessionId}.md using the schema in section 4. Update it whenever you rule out an approach, make a consequential decision, or change direction. Keep each section to 5 bullets max, one line per bullet.`
+}
+
+// Validates the 2-line header per schema v1:
+//   synthesis_version: 1
+//   session: <session-id>  updated: <ISO-8601 UTC>
+export function validateSynthesisHeader(text, { sessionId = null } = {}) {
+  if (typeof text !== 'string') return { valid: false, reason: 'content is not a string' }
+  const lines = text.split(/\r?\n/)
+  if (lines.length < 2) return { valid: false, reason: 'fewer than 2 lines' }
+
+  const l0 = lines[0].trim()
+  if (!/^synthesis_version:\s*1$/.test(l0)) {
+    return { valid: false, reason: 'missing or invalid synthesis_version: 1' }
+  }
+
+  const l1 = lines[1].trim()
+  const m = /^session:\s*(\S+)\s+updated:\s*(\S+)$/.exec(l1)
+  if (!m) {
+    return { valid: false, reason: 'missing or invalid session/updated header line' }
+  }
+
+  const [, sessId, updated] = m
+  if (sessionId && sessId !== sessionId) {
+    return { valid: false, reason: `session mismatch: expected ${sessionId}, got ${sessId}` }
+  }
+
+  const parsed = Date.parse(updated)
+  if (Number.isNaN(parsed) || !/(?:Z|[+-]00:?00)$/i.test(updated)) {
+    return { valid: false, reason: 'updated timestamp is not valid ISO-8601 UTC' }
+  }
+
+  return { valid: true, version: 1, session: sessId, updated }
+}
+
+// Validates the full schema v1: header + optional sections in fixed order with max 5 bullets each
+export function validateSynthesis(text, { sessionId = null } = {}) {
+  const header = validateSynthesisHeader(text, { sessionId })
+  const errors = []
+  if (!header.valid) {
+    errors.push(header.reason)
+  }
+
+  if (typeof text !== 'string') {
+    return { valid: false, headerValid: false, errors: ['content is not a string'] }
+  }
+
+  const lines = text.split(/\r?\n/)
+  let lastSectionIdx = -1
+  let currentSection = null
+  let currentBullets = 0
+
+  for (let i = 2; i < lines.length; i++) {
+    const line = lines[i].trim()
+    if (line.startsWith('## ')) {
+      const idx = SYNTHESIS_SECTIONS.indexOf(line)
+      if (idx === -1) {
+        errors.push(`unknown section: ${line}`)
+      } else if (idx <= lastSectionIdx) {
+        errors.push(`section out of order: ${line}`)
+      } else {
+        lastSectionIdx = idx
+      }
+      currentSection = line
+      currentBullets = 0
+    } else if (line.startsWith('- ')) {
+      currentBullets++
+      if (currentBullets > 5) {
+        errors.push(`section ${currentSection || 'unknown'} exceeds 5 bullets`)
+      }
+    }
+  }
+
+  return {
+    valid: errors.length === 0,
+    headerValid: header.valid,
+    errors,
+    session: header.session ?? null,
+    updated: header.updated ?? null,
+  }
+}
+
+// Inlines synthesis into the ## Synthesis section with size cap (4 KB) and malformed header handling
+export function formatSynthesisSection(rawText, { sessionId = null } = {}) {
+  if (!rawText || !rawText.trim()) return ''
+
+  let content = rawText
+  const buf = Buffer.from(content, 'utf8')
+  if (buf.length > MAX_SYNTHESIS_BYTES) {
+    const sliced = buf.subarray(0, MAX_SYNTHESIS_BYTES).toString('utf8')
+    const sep = sliced.endsWith('\n') ? '' : '\n'
+    content = `${sliced}${sep}${TRUNCATED_MARKER}`
+  }
+
+  const header = validateSynthesisHeader(content, { sessionId })
+  if (!header.valid) {
+    content = `${INVALID_HEADER_PREFIX}\n${content}`
+  }
+
+  return `## Synthesis\n\n${content.trim()}`
+}
+
+// True if .leg/SYNTHESIS-<session-id>.md exists, is non-empty, and was modified within the last 3 checkpoints
+export function hasRecentSynthesis(session) {
+  if (!session) return false
+  const root = session.worktree?.path ?? session.repo ?? session.cwd ?? null
+  if (!root || !session.session_id) return false
+  const file = synthesisFile(root, session.session_id)
+  try {
+    if (!existsSync(file)) return false
+    const st = statSync(file)
+    if (!st.isFile() || st.size === 0) return false
+    const checkpoints = session.checkpoints ?? []
+    if (checkpoints.length < 3) return true
+    const threshold = new Date(checkpoints[checkpoints.length - 3]).getTime()
+    return st.mtimeMs >= threshold
+  } catch {
+    return false
+  }
+}

package/src/taps/agy.mjs

@@ -1,8 +1,8 @@
 // agy tap — Antigravity CLI 1.2.0 is a closed Go binary with no hooks and no
-// usage percentage on any surface Baton can read (its own status line fetches
+// usage percentage on any surface Leg can read (its own status line fetches
 // a quota summary from the backend; the value is not written anywhere). What
 // it does give:
-//   --log-file <path>       one log per Baton session; the wall shows up as
+//   --log-file <path>       one log per Leg session; the wall shows up as
 //                           RESOURCE_EXHAUSTED / "it resets in <d>" / "out of quota"
 //                           (strings present in agy.exe; docs-only until hit live)
 //   ~/.gemini/antigravity-cli/history.jsonl

package/src/taps/claude-usage.mjs

@@ -3,7 +3,7 @@
 // Why not the status line: Claude Code 2.1.268 renders its built-in status
 // line and does not run a custom `statusLine` command passed via --settings
 // or a project settings file (verified 2026-09-11 with an `echo` command at
-// both levels; hooks from the same --settings file do run). So Baton asks the
+// both levels; hooks from the same --settings file do run). So Leg asks the
 // usage endpoint directly with the OAuth token Claude Code stored at login.
 // The token is read by this process only, sent only to api.anthropic.com,
 // and never written anywhere (the ledger scrubs bearer tokens regardless).