@ucsandman/legcli 0.13.1 → 0.15.0

package/src/sessions.mjs

@@ -3,8 +3,10 @@
 //   session.json   the live record the board renders (atomic writes)
 //   events.jsonl   timeline (started, turn, warning, limit, handoff, ended)
 //   control.json   board → runner requests ({ handoff: true })
-// The runner (src/attach.mjs) is the only writer of session.json; hooks and
-// taps go through recordFromTap() so every write is one atomic replace.
+// The runner (src/attach.mjs) owns session.json; the board's usage poller,
+// Claude Code's hooks (src/taps/claude.mjs) and a board action patch fields on
+// it too, all through updateSession(), so every write is one atomic replace
+// under .session.lock and no writer loses another's field.
 import { existsSync, mkdirSync, readdirSync, readFileSync, appendFileSync, rmSync } from 'node:fs'
 import { join } from 'node:path'
 import { randomBytes } from 'node:crypto'
@@ -95,6 +97,12 @@ export function createSession({ id, agent, account = 'default', cwd, repo = null
 // processes cannot lose an accumulated field (files_touched, turns) to a
 // last-writer-wins race. Callers that only set fixed values pass a plain object.
 export function updateSession(id, patch, { event } = {}) {
+  // run.json's lock budget (250 tries, a 10 s steal), not withFileLock's
+  // default: past 1.2 s the default runs the read-modify-write UNLOCKED, and
+  // this file has the most writers in Leg — the terminal's poll, the claude
+  // hook, the board's usage poller, the board's order editor and every
+  // `leg` command. One of them losing its patch is the race the lock exists
+  // for, and the terminal is never the one that must not block.
   return withFileLock(join(sessionDir(id), '.session.lock'), () => {
     const cur = readSession(id)
     if (!cur) return null
@@ -113,7 +121,7 @@ export function updateSession(id, patch, { event } = {}) {
     writeJsonAtomic(join(sessionDir(id), 'session.json'), next)
     if (event) appendEvent(id, event)
     return next
-  })
+  }, { retries: 250, staleMs: 10000 })
 }
 
 export function appendEvent(id, ev) {
@@ -152,6 +160,13 @@ export function takeControl(id) {
     return req
   })
 }
+// The last thing a leg does: the terminal is gone, so a request nobody will
+// read is removed. Under the same lock requestControl writes it with — a bare
+// unlink from this side could delete a board request mid-write.
+export function clearControl(id) {
+  const f = join(sessionDir(id), 'control.json')
+  return withFileLock(join(sessionDir(id), '.control.lock'), () => { rmSync(f, { force: true }) })
+}
 
 export function removeSession(id) { rmSync(sessionDir(id), { recursive: true, force: true }) }
 

package/src/synthesis.mjs

@@ -1,7 +1,7 @@
 // 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 { existsSync, readFileSync, readdirSync, statSync } from 'node:fs'
 import { join } from 'node:path'
 
 export const MAX_SYNTHESIS_BYTES = 4096
@@ -145,14 +145,33 @@ export function formatSynthesisSection(rawText, { sessionId = null } = {}) {
   return `## Synthesis\n\n${content.trim()}`
 }
 
+// Every per-session file one checkout keeps, name → path, `.leg` winning over
+// the legacy `.baton` for a name both hold (the same order synthesisFile
+// probes in). One readdir per directory answers the question for every
+// terminal in that checkout at once, where a path-by-path probe cost three
+// existsSync per terminal — 172 of the 512 fs calls in one sessions view, for
+// files that mostly are not there. `cache` is per view: a Map the caller owns,
+// so nothing here outlives the request that asked.
+export function sessionFileIndex(cwd, cache = null) {
+  if (cache && cache.has(cwd)) return cache.get(cwd)
+  const names = new Map()
+  for (const dir of ['.leg', '.baton']) {
+    let entries
+    try { entries = readdirSync(join(cwd, dir)) } catch { continue }
+    for (const n of entries) if (!names.has(n)) names.set(n, join(cwd, dir, n))
+  }
+  cache?.set(cwd, names)
+  return names
+}
+
 // True if .leg/SYNTHESIS-<session-id>.md exists, is non-empty, and was modified within the last 3 checkpoints
-export function hasRecentSynthesis(session) {
+export function hasRecentSynthesis(session, { index = null } = {}) {
   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)
+  const file = sessionFileIndex(root, index).get(`SYNTHESIS-${session.session_id}.md`)
+  if (!file) return false
   try {
-    if (!existsSync(file)) return false
     const st = statSync(file)
     if (!st.isFile() || st.size === 0) return false
     const checkpoints = session.checkpoints ?? []

package/src/usage.mjs

@@ -21,8 +21,9 @@ import { join } from 'node:path'
 import { home } from './store.mjs'
 import { writeJsonAtomic, withFileLock } from './fsx.mjs'
 import { AGENTS } from './sessions.mjs'
-import { ACCOUNT_NAME_RE } from './accounts.mjs'
+import { ACCOUNT_NAME_RE, transcriptReachable } from './accounts.mjs'
 import { rungCost, staticCost } from './preferences.mjs'
+import { isDownshift } from './buckets.mjs'
 
 export const WARN_PCT = Number((process.env.LEG_WARN_PCT || process.env.BATON_WARN_PCT) || 85)
 // A limit hit with no reset time from the agent: assume the 5-hour window.
@@ -464,6 +465,31 @@ export function rungLabel(r) {
   return `${r.agent}${r.account && r.account !== 'default' ? '/' + r.account : ''}${r.model ? '/' + r.model : ''}`
 }
 
+// The hand-off that keeps the conversation instead of taking the bundle: the
+// next leg starts `claude --resume <id>` inside the same transcript, so nothing
+// is re-explained. Two cases, one rule, read by the terminal (src/attach.mjs)
+// and by the board's picker (src/server.mjs) so the row and the switch agree:
+//   1. a downshift on the same login (fixtures/live/claude/resume-model-probe.json:
+//      the conversation survives and only the new model answers; an upshift
+//      would re-read the whole context at the stronger model's price, so it
+//      takes the bundle);
+//   2. another login of the same agent whose home can see the transcript
+//      (the `projects` junction src/accounts.mjs cuts for every account). A
+//      weekly or Fable wall on one 20x login then moves the terminal to the
+//      other login with the conversation it already had, at whatever model the
+//      rung names or the destination's own default.
+// codex has a `resume` subcommand too, but composing it with `-m` and with a
+// second CODEX_HOME is unobserved, so codex never claims to keep anything.
+export function keepsConversation({ from, to, session }) {
+  if (!session?.agent_session_id || !from || !to) return false
+  if (from.agent !== 'claude' || to.agent !== 'claude') return false
+  if (isDownshift(from, to)) return true
+  const a = from.account ?? 'default'
+  const b = to.account ?? 'default'
+  if (a === b) return false
+  return transcriptReachable('claude', session.transcript_path, { from: a, to: b })
+}
+
 // One ledger line for a rung that was passed over. Exact wording matters: this
 // is what the terminal and the card say instead of going somewhere unexplained.
 export function skipLine(r) {