spexcode 0.6.2 → 0.6.5

package/spec-cli/src/search.ts

@@ -1,63 +0,0 @@
-import { loadSpecsLite } from './specs.js'
-import { rankDocs, type RankInput } from './ranker.js'
-
-export type SearchResult = { id: string; title: string; path: string; score: number; snippet: string }
-export type SearchStats = { nodes: number; tokens: number; ms: number }
-
-// zero-result fallback: nearest node titles by per-word edit distance over title+id — the lightweight
-// string distance that routes a typo'd query to a next step. Each query word takes its best normalised
-// Levenshtein similarity against any title/id word (≥0.5, so unrelated words don't accumulate), then the
-// words sum. Same loadSpecsLite read as the ranker; deliberately NOT part of rankDocs scoring (this
-// tolerates typos, the ranker must not).
-export function nearestTitles(query: string, n = 3): { id: string; title: string }[] {
-  const words = (s: string) => s.toLowerCase().split(/[^a-z0-9]+/).filter((w) => w.length > 1)
-  const lev = (a: string, b: string) => {
-    const dp = Array.from({ length: b.length + 1 }, (_, i) => i)
-    for (let i = 1; i <= a.length; i++) {
-      let prev = dp[0]
-      dp[0] = i
-      for (let j = 1; j <= b.length; j++) {
-        const cur = dp[j]
-        dp[j] = Math.min(dp[j] + 1, dp[j - 1] + 1, prev + (a[i - 1] === b[j - 1] ? 0 : 1))
-        prev = cur
-      }
-    }
-    return dp[b.length]
-  }
-  const qws = words(query)
-  if (!qws.length) return []   // nothing to be "near" (e.g. a pure-CJK query) — the caller still points at spex graph
-  return loadSpecsLite()
-    .map((s) => {
-      const tws = [...new Set(words(`${s.title} ${s.id}`))]
-      let score = 0
-      for (const q of qws) {
-        let best = 0
-        for (const t of tws) best = Math.max(best, 1 - lev(q, t) / Math.max(q.length, t.length))
-        if (best >= 0.5) score += best
-      }
-      return { id: s.id, title: s.title, score }
-    })
-    .filter((s) => s.score > 0)
-    .sort((a, b) => b.score - a.score)
-    .slice(0, n)
-    .map(({ id, title }) => ({ id, title }))
-}
-
-export async function searchSpecs(query: string, opts: { limit?: number; onStats?: (s: SearchStats) => void } = {}): Promise<SearchResult[]> {
-  const t0 = performance.now()
-  // pre-sort by (shorter id, then id): rankDocs sorts stably, so for equal-scored nodes this IS the tiebreak.
-  const nodes = loadSpecsLite()
-    .slice()
-    .sort((a, b) => a.id.length - b.id.length || a.id.localeCompare(b.id))
-  const inputs: RankInput<(typeof nodes)[number]>[] = nodes.map((s) => ({
-    ref: s, name: `${s.title} ${s.id}`, desc: s.desc, body: s.body,
-  }))
-  const out = rankDocs(query, inputs, { limit: opts.limit }).map((r) => ({
-    id: r.ref.id, title: r.ref.title, path: r.ref.path, score: r.score, snippet: r.snippet,
-  }))
-  if (opts.onStats) {
-    const tokens = inputs.reduce((a, i) => a + `${i.name} ${i.desc} ${i.body}`.split(/[^a-z0-9]+/i).filter(Boolean).length, 0)
-    opts.onStats({ nodes: inputs.length, tokens, ms: performance.now() - t0 })
-  }
-  return out
-}

package/spec-cli/src/session-cursors.ts

@@ -1,91 +0,0 @@
-import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs'
-import { join } from 'node:path'
-import { sessionArtifactPath, sessionStoreDir } from './layout.js'
-import type { TimelineEvent } from './session-timeline.js'
-
-// @@@ session-cursors - a reader's durable place in a log. One `cursors.json` per session in its global store
-// dir: `follows` holds one entry per followed session, including the reader's own id when it watches its own
-// log. A position is an event INDEX into timeline.ndjson (lines already consumed), so it is also the index of
-// the next unread event. A position is NOT a work list: what a session still owes its agent is a debt, and it
-// lives in its own queue ([[delivery-queue]]). Binding both to one counter is what made a session's own status
-// lines get consumed as though they were mail, and made "anything outstanding?" a scan of all history.
-
-export type Cursors = { version: 1; follows: Record<string, number> }
-
-const cursorsPath = (id: string): string => sessionArtifactPath(id, 'cursors.json')
-const at = (v: unknown): number => (typeof v === 'number' && Number.isFinite(v) && v > 0 ? Math.floor(v) : 0)
-
-// Never throws: a missing, empty, or unparseable file reads as "nothing consumed", because re-showing a
-// message is the honest recovery for a lost position and skipping one is not. Followed entries whose target
-// store dir is gone are dropped here — expiry is this read, and the next write persists it.
-export function readCursors(id: string): Cursors {
-  let raw: { follows?: unknown } | null = null
-  try { raw = JSON.parse(readFileSync(cursorsPath(id), 'utf8')) } catch { /* no cursors yet */ }
-  const follows: Record<string, number> = {}
-  const stored = raw?.follows
-  if (stored && typeof stored === 'object') {
-    for (const [target, pos] of Object.entries(stored as Record<string, unknown>)) {
-      if (!target || !existsSync(sessionStoreDir(target))) continue
-      follows[target] = at(pos)
-    }
-  }
-  return { version: 1, follows }
-}
-
-// Written whole and atomically, one field per line — the same shape as the session record, so a position stays
-// readable by an exact whole-line match where a value regex would not be.
-function writeCursors(id: string, cursors: Cursors): void {
-  const dir = sessionStoreDir(id)
-  mkdirSync(dir, { recursive: true })
-  const tmp = join(dir, `.cursors.json.${process.pid}.tmp`)
-  writeFileSync(tmp, JSON.stringify(cursors, null, 2) + '\n')
-  renameSync(tmp, cursorsPath(id))
-}
-
-export const followCursor = (id: string, target: string): number | null => {
-  const stored = readCursors(id).follows[target]
-  return stored === undefined ? null : stored
-}
-
-// Start or advance a follow. Following IS this entry existing, so the first call registers the relationship.
-// Monotonic: a stale read can leave a position too low (an event read twice), never too high (one lost).
-export function advanceFollow(id: string, target: string, to: number): void {
-  const cursors = readCursors(id)
-  const stored = cursors.follows[target]
-  if (stored !== undefined && to <= stored) return
-  writeCursors(id, { ...cursors, follows: { ...cursors.follows, [target]: Math.max(0, Math.floor(to)) } })
-}
-
-export const followedSessions = (id: string): string[] => Object.keys(readCursors(id).follows)
-
-const sameStatus = (a: TimelineEvent, b: TimelineEvent): boolean =>
-  a.kind === 'status' && b.kind === 'status' && a.status === b.status
-  && (a.proposal ?? null) === (b.proposal ?? null) && (a.note ?? null) === (b.note ?? null)
-
-// @@@ edges, not lines - what a reader has not yet seen, with repeated status lines dropped. X→X IS NOT A
-// TRANSITION: the log is append-only and already holds runs of identical status lines from before the
-// timeline observer was deleted (every stray `spex serve` process ran an fs.watch over the same store and
-// re-recorded each real move, so ONE transition landed as up to 6 lines within ~200ms). Those bytes are
-// history and stay. Any consumer that decides "did it move?" must therefore compare VALUES, never adjacency,
-// and must compare against the last status the reader ALREADY saw — otherwise a duplicate straddling the
-// cursor boundary reads as a fresh move on the very next tick. `next` is where the cursor goes after consuming
-// the WHOLE slice: the full length, because a dropped duplicate is still consumed. `at[i]` is the absolute
-// index of `events[i]`, which is what lets a reader that STOPS on one event ([[session-follow]]'s take-one
-// wait) advance to exactly `at[i] + 1` and leave the lines behind it unread for the next reader.
-export function unreadSince(events: TimelineEvent[], from: number): { events: TimelineEvent[]; at: number[]; next: number } {
-  const start = Math.min(Math.max(0, Math.floor(from)), events.length)
-  let prev: TimelineEvent | null = null
-  for (let i = start - 1; i >= 0; i--) if (events[i].kind === 'status') { prev = events[i]; break }
-  const out: TimelineEvent[] = []
-  const at: number[] = []
-  for (let i = start; i < events.length; i++) {
-    const e = events[i]
-    if (e.kind === 'status') {
-      if (prev && sameStatus(prev, e)) continue
-      prev = e
-    }
-    out.push(e)
-    at.push(i)
-  }
-  return { events: out, at, next: events.length }
-}

package/spec-cli/src/session-execution.ts

@@ -1,68 +0,0 @@
-import { streamSSE } from 'hono/streaming'
-import type { Context } from 'hono'
-import { harnessById } from './harness.js'
-import { readAliasedRawRecord } from './layout.js'
-import { currentHumanTurn } from './session-timeline.js'
-import type { ExecutionStep, ExecutionTurn } from './execution-trace.js'
-
-export type SessionExecution = Readonly<{
-  revision: string
-  turnId: string | null
-  workingNote: string | null
-  steps: readonly ExecutionStep[]
-}>
-
-const absentExecution = (turn: ExecutionTurn | null = null): SessionExecution => ({ revision: `turn:${turn?.token ?? '0'}`, turnId: turn?.token ?? null, workingNote: null, steps: [] })
-
-// This is deliberately a read projection. Native transcript bytes stay within the adapter, while the API owns
-// only enough information for the frontend's fixed renderer to paint the current execution slice.
-export function readSessionExecution(id: string): SessionExecution | null {
-  let record: ReturnType<typeof readAliasedRawRecord>
-  try { record = readAliasedRawRecord(id) } catch { return null }
-  if (!record?.governed) return null
-  const turn = currentHumanTurn(id)
-  const threadId = typeof record.harness_session_id === 'string' ? record.harness_session_id : ''
-  if (!threadId) return absentExecution(turn)
-  try {
-    const trace = harnessById(typeof record.harness === 'string' && record.harness ? record.harness : 'claude')
-      .executionTrace(threadId, turn)
-    return trace || absentExecution(turn)
-  } catch {
-    // A missing/unreadable native source is an absent transient trace, not a synthetic conversation failure.
-    return absentExecution(turn)
-  }
-}
-
-const TRACE_TICK_MS = 500
-const HEARTBEAT_TICKS = 20
-
-export async function sessionExecutionStream(c: Context) {
-  const id = c.req.param('id') || ''
-  if (!readSessionExecution(id)) return c.json({ error: 'no such session' }, 404)
-  return streamSSE(c, async (stream) => {
-    let aborted = false
-    let lastRevision = ''
-    let ticks = 0
-    const publish = async (): Promise<boolean> => {
-      const execution = readSessionExecution(id)
-      if (!execution) return false
-      if (execution.revision === lastRevision) return true
-      lastRevision = execution.revision
-      await stream.writeSSE({ event: 'execution', data: JSON.stringify(execution) })
-      return true
-    }
-
-    stream.onAbort(() => { aborted = true })
-    try {
-      if (!await publish()) return
-      while (!aborted) {
-        await stream.sleep(TRACE_TICK_MS)
-        if (aborted) break
-        if (!await publish()) break
-        if (++ticks % HEARTBEAT_TICKS === 0) await stream.writeSSE({ event: 'ping', data: 'x' })
-      }
-    } catch {
-      // EventSource reconnects a dropped stream. A native trace read must never take down the session server.
-    }
-  })
-}

package/spec-cli/src/session-files.ts

@@ -1,121 +0,0 @@
-import { accessSync, constants, readFileSync, renameSync, statSync, unlinkSync, writeFileSync } from 'node:fs'
-import { basename, isAbsolute, resolve } from 'node:path'
-import { readRecordEntry, sessionArtifactPath } from './layout.js'
-
-export class SessionFileError extends Error {
-  constructor(readonly status: 400 | 403 | 404 | 500, message: string) {
-    super(message)
-    this.name = 'SessionFileError'
-  }
-}
-
-type SessionFileLock = <T>(id: string, body: () => T) => T
-
-export const SESSION_FILE_PREVIEW_MAX_BYTES = 2 * 1024 * 1024
-export type SessionFilePreviewKind = 'text' | 'image'
-const TEXT_EXTENSIONS = new Set(['.txt', '.md', '.markdown', '.json', '.yaml', '.yml', '.toml', '.ini', '.log', '.csv', '.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs', '.css', '.html', '.xml', '.py', '.go', '.rs', '.java', '.sh', '.sql'])
-const IMAGE_TYPES: Record<string, string> = {
-  '.png': 'image/png', '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg', '.gif': 'image/gif', '.webp': 'image/webp',
-}
-
-const filesPath = (id: string) => sessionArtifactPath(id, 'files.json')
-
-function requireSession(id: string): void {
-  const record = readRecordEntry(id)
-  if (record.kind === 'absent') throw new SessionFileError(404, `session ${id} does not exist`)
-  if (record.kind === 'corrupt') throw new SessionFileError(500, `session ${id} has an unreadable record: ${record.error}`)
-}
-
-function readFiles(id: string): string[] {
-  const path = filesPath(id)
-  let parsed: unknown
-  try { parsed = JSON.parse(readFileSync(path, 'utf8')) }
-  catch (error) {
-    if ((error as NodeJS.ErrnoException).code === 'ENOENT') return []
-    throw new SessionFileError(500, `session file list is unreadable: ${path} — ${error instanceof Error ? error.message : String(error)}`)
-  }
-  if (!Array.isArray(parsed) || parsed.some((value) => typeof value !== 'string' || !isAbsolute(value)))
-    throw new SessionFileError(500, `session file list is invalid: ${path}`)
-  return [...new Set(parsed)]
-}
-
-function writeFiles(id: string, files: string[]): void {
-  const path = filesPath(id)
-  const tmp = `${path}.${process.pid}.tmp`
-  try {
-    writeFileSync(tmp, `${JSON.stringify(files, null, 2)}\n`)
-    renameSync(tmp, path)
-  } finally {
-    try { unlinkSync(tmp) } catch { /* rename already consumed the temporary file */ }
-  }
-}
-
-function currentFile(path: string): void {
-  try {
-    if (!statSync(path).isFile()) throw new SessionFileError(400, `not a regular file: ${path}`)
-    accessSync(path, constants.R_OK)
-  } catch (error) {
-    if (error instanceof SessionFileError) throw error
-    const code = (error as NodeJS.ErrnoException).code
-    if (code === 'ENOENT' || code === 'ENOTDIR') throw new SessionFileError(404, `file does not exist: ${path}`)
-    throw new SessionFileError(403, `file is not readable: ${path}`)
-  }
-}
-
-export function listSessionFiles(id: string): string[] {
-  requireSession(id)
-  return readSessionFiles(id)
-}
-
-// Session projections already hold a parsed record; re-checking session.json here would make an in-memory
-// projection depend on the public route's existence guard. The route-facing list keeps that guard above.
-export function readSessionFiles(id: string): string[] {
-  return readFiles(id)
-}
-
-export function addSessionFile(id: string, input: string, lock: SessionFileLock, cwd = process.cwd()): { path: string; added: boolean } {
-  const path = resolve(cwd, input)
-  currentFile(path)
-  return lock(id, () => {
-    requireSession(id)
-    const files = readFiles(id)
-    if (files.includes(path)) return { path, added: false }
-    writeFiles(id, [...files, path])
-    return { path, added: true }
-  })
-}
-
-export function retractSessionFile(id: string, input: string, lock: SessionFileLock, cwd = process.cwd()): { path: string; removed: boolean } {
-  const path = resolve(cwd, input)
-  return lock(id, () => {
-    requireSession(id)
-    const files = readFiles(id)
-    if (!files.includes(path)) return { path, removed: false }
-    writeFiles(id, files.filter((file) => file !== path))
-    return { path, removed: true }
-  })
-}
-
-export function openSessionFile(id: string, path: string): { path: string; name: string; size: number } {
-  requireSession(id)
-  if (!readFiles(id).includes(path)) throw new SessionFileError(403, 'that path was not posted by this session')
-  try {
-    const stat = statSync(path)
-    if (!stat.isFile()) throw new SessionFileError(404, `file no longer exists: ${path}`)
-    accessSync(path, constants.R_OK)
-    return { path, name: basename(path) || 'download', size: stat.size }
-  } catch (error) {
-    if (error instanceof SessionFileError) throw error
-    throw new SessionFileError(404, `file no longer exists: ${path}`)
-  }
-}
-
-export function sessionFilePreviewKind(path: string): { kind: SessionFilePreviewKind; contentType: string } | null {
-  const extension = basename(path).toLowerCase().match(/\.[^.]+$/)?.[0]
-  if (!extension) return null
-  if (TEXT_EXTENSIONS.has(extension)) return { kind: 'text', contentType: 'text/plain; charset=utf-8' }
-  const contentType = IMAGE_TYPES[extension]
-  return contentType ? { kind: 'image', contentType } : null
-}
-
-export const sessionFilesPath = (id: string) => filesPath(id)

package/spec-cli/src/session-follow.ts

@@ -1,182 +0,0 @@
-import { existsSync } from 'node:fs'
-import { sessionStoreDir } from './layout.js'
-import { advanceFollow, followCursor, unreadSince } from './session-cursors.js'
-import { timelineDisplay, timelineEvents, timelineStamp } from './session-timeline.js'
-import { sessionTitle, type DisplayStatus, type Session } from './sessions.js'
-
-// @@@ session-follow - supervision is FOLLOWING a log past a cursor, never polling a derived board. One tick
-// costs ONE stat per target: if timeline.ndjson has not grown, nothing is opened and nothing is parsed. No
-// call here reaches the backend, a rendezvous socket, or tmux, which is the whole point — M followers over N
-// sessions cost the control plane zero, where the old poll cost one board build (a connect + a tmux spawn per
-// live session) per follower per interval.
-
-// Actionable = a state whose arrival means "a human/supervisor must now act". `offline` is deliberately ABSENT
-// where the old poll had it: liveness is a present-tense probe derivation, never authored, so it can never
-// appear on a log ([[state]]). A follower learns what a session DECLARED and never that it died.
-const ACTIONABLE = new Set<DisplayStatus>(['review', 'done', 'close-pending', 'error', 'asking'])
-const NEXT: Record<string, string> = {
-  review: 'merge | close',
-  done: 'merge | close',
-  'close-pending': 'close',
-  error: 'resume (relaunch & retry) | show --capture | close',
-  asking: 'send "<msg>" | show --capture',
-  idle: 'send "<msg>" | show --capture',
-  queued: 'waiting for a free slot — starts automatically | close',
-}
-const trunc = (s: string, n: number): string => (s.length <= n ? s : `${s.slice(0, n - 1)}…`)
-
-export function sessionEvent(s: Session): string {
-  const note = s.note ? ` — note: ${s.note}` : ''
-  const asked = s.promptPreview ? ` · asked: ${s.promptPreview}` : ''
-  return `[spex] ${s.status} · ${sessionTitle(s)} — act: ${NEXT[s.status] || '—'}${note}${asked}  [id ${s.id}]`
-}
-// @@@ launchEvent - a session's FIRST sighting, emitted once per id whatever its status, so the stream is a
-// complete lifecycle feed: launched → [transitions] → closed. A launch's own first line is `active` (not
-// actionable), so without this the feed would be blind to new sessions starting.
-export function launchEvent(s: Session): string {
-  const note = s.note ? ` — note: ${s.note}` : ''
-  const asked = s.promptPreview ? ` · asked: ${s.promptPreview}` : ''
-  return `[spex] launched · ${sessionTitle(s)} — act: capture | send "<msg>"${note}${asked}  [id ${s.id}]`
-}
-
-// `targets` is re-read every tick so a BROAD follow picks up sessions that launch while it runs; an explicit
-// selector resolves once and hands back a fixed list. `self` is the follower's own session: its inbox rides the
-// same follow, and it is where the durable cursors live — a follower with no session record (a human shell)
-// keeps them in memory for the life of the process.
-export type FollowOpts = {
-  targets: () => string[]
-  self?: string | null
-  statuses?: string[]
-  includeIdle?: boolean
-  intervalMs?: number
-  as?: string
-  take?: boolean
-  timeoutMs?: number
-  onObserved?: (id: string, status: DisplayStatus, previous: DisplayStatus | null) => void
-  row?: (id: string, status: DisplayStatus, note: string | null) => Session | null
-}
-// Only `take` mode (what `spex session wait` runs) resolves; a stream follow never returns. There is no
-// transport outcome, because there is no transport: following is reading a file, so the failure that once
-// needed its own vocabulary — a backend that could not be reached, misread as a session verdict — cannot occur.
-export type FollowOutcome =
-  | { reached: DisplayStatus; id: string; path: DisplayStatus[] }
-  | { mail: { from: string | null; text: string } }
-  | { timedOut: true; path: DisplayStatus[] }
-  | { gone: string }
-
-type FollowState = { pos: number; prev: DisplayStatus | null; path: DisplayStatus[]; stamp: string | null }
-
-export async function followSessions(emit: (line: string) => void, opts: FollowOpts): Promise<FollowOutcome> {
-  const { targets, self = null, statuses, includeIdle = false, intervalMs = 1000, as, take = false, timeoutMs = 1_200_000, onObserved, row } = opts
-  const tag = as ? `[${as}] ` : ''
-  const state = new Map<string, FollowState>()
-  const memo = new Map<string, number>()   // cursors for a follower that has no record of its own to store them in
-  const sleep = (ms: number) => new Promise((r) => setTimeout(r, ms))
-  // the no-hang wall: a fixed deadline computed ONCE, checked before EVERY sleep below.
-  const deadline = take ? Date.now() + Math.max(1000, timeoutMs) : 0
-  const isActionable = (st: DisplayStatus) => ACTIONABLE.has(st) || (includeIdle && st === 'idle')
-  const passes = (st: DisplayStatus) => !statuses?.length || statuses.includes(st)
-  const anyPath = (): DisplayStatus[] => {
-    for (const f of state.values()) if (f.path.length) return f.path
-    return []
-  }
-  const readCursor = (id: string): number | null => (self ? followCursor(self, id) : memo.get(id) ?? null)
-  const writeCursor = (id: string, to: number): void => { if (self) advanceFollow(self, id, to); else memo.set(id, to) }
-  const line = (id: string, st: DisplayStatus, note: string | null, first: boolean): void => {
-    const s = row?.(id, st, note)
-    if (!s) return
-    if (first) emit(tag + launchEvent(s))
-    else if (passes(st) && isActionable(st)) emit(tag + sessionEvent(s))
-  }
-  let first = true
-  let shown = -1   // stream mode: the last inbox line this process printed (see the INBOX read below)
-
-  for (;;) {
-    const ids = targets()
-    const seen = new Set<string>()
-    for (const id of ids) {
-      if (id === self) continue   // the follower's own log is its INBOX, followed below on its own cursor rule
-      seen.add(id)
-      if (!existsSync(sessionStoreDir(id))) {
-        if (state.delete(id)) emit(`${tag}[spex] closed · removed  [id ${id}]`)
-        if (take) return { gone: id }
-        continue
-      }
-      let f = state.get(id)
-      if (!f) {
-        const evs = timelineEvents(id)
-        // A stored cursor always wins — that IS the resume, losing nothing across a follower's death. With
-        // none: a target already present when the follow started predates it, so we begin at the log's END
-        // (its history is not news); a target that appears on a LATER tick genuinely just launched, so its
-        // whole log is read from 0 and its `launched` line reaches the feed.
-        const pos = readCursor(id) ?? (first ? evs.length : 0)
-        // The ARRIVAL state is the last status line BEFORE the cursor — a fact on the log, not whatever a poll
-        // happened to catch. With no such line the first status we read is the arrival instead.
-        let prev: DisplayStatus | null = null
-        for (let i = Math.min(pos, evs.length) - 1; i >= 0; i--) {
-          const e = evs[i]
-          if (e.kind === 'status') { prev = timelineDisplay(e); break }
-        }
-        f = { pos, prev, path: prev ? [prev] : [], stamp: null }
-        state.set(id, f)
-        if (prev) { onObserved?.(id, prev, null); line(id, prev, null, true) }
-      }
-      const stamp = timelineStamp(id)
-      if (stamp !== null && stamp === f.stamp) continue   // THE cheap tick: nothing appended, nothing parsed
-      f.stamp = stamp
-      const evs = timelineEvents(id)
-      const slice = unreadSince(evs, f.pos)
-      let hit: FollowOutcome | null = null
-      for (let k = 0; k < slice.events.length && !hit; k++) {
-        const e = slice.events[k]
-        if (e.kind === 'sent') {
-          const s = row?.(id, f.prev ?? 'unknown', null)
-          if (s) emit(`${tag}[spex] message · ${sessionTitle(s)} — from ${e.from ?? 'human'}: ${trunc(e.text, 120)}  [id ${id}]`)
-          continue
-        }
-        const st = timelineDisplay(e)
-        const was = f.prev
-        f.prev = st
-        f.path.push(st)
-        onObserved?.(id, st, was)
-        line(id, st, e.note, was === null)
-        // THE edge: a previously-observed NON-actionable status moving INTO an actionable one. An actionable
-        // ARRIVAL (was === null) is not an edge — that standing level is what a level-triggered wait falsely
-        // returned on; nor is an actionable→actionable hop (review→done). The rise OUT of non-actionable is the
-        // one signal that means "the target needs you AGAIN". The previous state is the previous LINE, so two
-        // moves inside one tick are two edges rather than one collapsed sample.
-        if (take && was !== null && !isActionable(was) && isActionable(st)) hit = { reached: st, id, path: f.path }
-        // Consume exactly up to the event we stopped on, so the lines behind it stay unread for the next wait.
-        if (hit) { f.pos = slice.at[k] + 1; writeCursor(id, f.pos) }
-      }
-      if (hit) return hit
-      f.pos = slice.next
-      writeCursor(id, f.pos)
-    }
-    for (const id of [...state.keys()]) {
-      if (seen.has(id)) continue
-      state.delete(id)
-      emit(`${tag}[spex] closed · removed  [id ${id}]`)
-    }
-    // THE FOLLOWER'S OWN LOG — watched exactly like any other target, on its own entry in `cursors.json`. It is
-    // a WATCH, not a delivery: a message reaches the agent as a prompt through the adapter ([[delivery-queue]]),
-    // so this position only decides what THIS process has already reported and can never make an agent miss
-    // mail. Never advanced here in take mode — the waiter stops on the event and the next wait resumes on it.
-    if (self && existsSync(sessionStoreDir(self))) {
-      const mine = unreadSince(timelineEvents(self), followCursor(self, self) ?? 0)
-      for (let k = 0; k < mine.events.length; k++) {
-        const e = mine.events[k]
-        if (e.kind !== 'sent') continue
-        if (take) return { mail: { from: e.from, text: e.text } }
-        // a stream has no turn boundary to advance that cursor, so its own high-water mark — process-local,
-        // never written — is what keeps an unread line from being re-printed on every tick.
-        if (mine.at[k] <= shown) continue
-        shown = mine.at[k]
-        emit(`${tag}[spex] message · you — from ${e.from ?? 'human'}: ${trunc(e.text, 120)}  [id ${self}]`)
-      }
-    }
-    first = false
-    if (take && Date.now() >= deadline) return { timedOut: true, path: anyPath() }
-    await sleep(intervalMs)
-  }
-}

package/spec-cli/src/session-reparent.ts

@@ -1,33 +0,0 @@
-import { apiBaseInfo, reparentSessionRecords, type SessionReparentResult } from './sessions.js'
-import { BackendError, backendConnectionRefused, clientReparent } from './client.js'
-
-export class SessionReparentRequestError extends Error {
-  constructor(message: string) {
-    super(message)
-    this.name = 'SessionReparentRequestError'
-  }
-}
-
-export function parseReparentRequest(body: unknown): { children: string[]; parent: string } {
-  if (!body || typeof body !== 'object') throw new SessionReparentRequestError('reparent body must be JSON')
-  const raw = body as { children?: unknown; parent?: unknown }
-  if (!Array.isArray(raw.children) || !raw.children.length || raw.children.some((id) => typeof id !== 'string' || !id.trim()))
-    throw new SessionReparentRequestError('reparent children must be one or more session ids')
-  if (typeof raw.parent !== 'string' || !raw.parent.trim()) throw new SessionReparentRequestError('reparent parent must be a session id')
-  return { children: raw.children.map((id) => id.trim()), parent: raw.parent.trim() }
-}
-
-export async function reparentRequest(body: unknown): Promise<SessionReparentResult> {
-  const request = parseReparentRequest(body)
-  return reparentSessionRecords(request.children, request.parent)
-}
-
-export async function reparentSessions(children: string[], parent: string): Promise<SessionReparentResult> {
-  try {
-    return await clientReparent(children, parent)
-  } catch (error) {
-    if (!(error instanceof BackendError) || (await apiBaseInfo()).source === 'flag' || !backendConnectionRefused(error)) throw error
-    console.error('spex: no backend reachable — reparenting in-process under the session record locks')
-    return reparentSessionRecords(children, parent)
-  }
-}