spexcode 0.5.2 → 0.5.4

package/spec-cli/src/pty-bridge.ts

@@ -1,7 +1,8 @@
 import { execFile, spawn, type ChildProcessWithoutNullStreams } from 'node:child_process'
 import { fileURLToPath } from 'node:url'
 import { promisify } from 'node:util'
-import { alive } from './sessions.js'
+import { alive, withSessionInputLock } from './sessions.js'
+import { runSessionOperationSync } from './session-maintenance.js'
 
 const pexec = promisify(execFile)
 const TMUX_SOCK = process.env.SPEXCODE_TMUX || 'spexcode'
@@ -362,8 +363,10 @@ const MAX_INPUT_BYTES = 64 * 1024
 export function forwardInput(id: string, viewer: Viewer, data: string): boolean {
   const subscription = currentSubscription(id, viewer)
   if (!subscription?.visible || !subscription.bridge || !data || Buffer.byteLength(data, 'utf8') > MAX_INPUT_BYTES) return false
-  sendControl(subscription.bridge, { t: 'input', data })
-  return true
+  return runSessionOperationSync({ op: 'terminal-input', sessionId: id }, () => withSessionInputLock(id, () => {
+      sendControl(subscription.bridge!, { t: 'input', data })
+      return true
+    }) ?? false)
 }
 
 async function restoreBridge(id: string, viewer: Viewer, subscription: Subscription): Promise<void> {

package/spec-cli/src/reviews.ts

@@ -15,6 +15,11 @@ import { EVAL_QUERY_DEFAULT, ISSUE_QUERY_DEFAULT, readToken } from '../../spec-d
 export const REVIEW_PER_PAGE = 25
 
 type ReviewItem = Record<string, unknown>
+// A section count is one number, or — when the domain adapter splits that section — its named buckets,
+// which re-add to the same whole population ([[review-filters]] owns the split; Evals splits its measured
+// verdicts into {fresh,stale} so the remeasurement debt travels with the count instead of being recomputed
+// per surface). The fold happens ONCE, here on the server, over the complete filtered population.
+export type ReviewCount = number | Record<string, number>
 type ReviewOption = { value: string; label?: string; count?: number }
 type ReviewFacet = { key: string; label?: string; value: string; meaningful?: boolean; options: ReviewOption[] }
 type EvalNeighbor = { node: string; scenario: string; state: string }
@@ -29,7 +34,7 @@ export type PagedReview<T extends ReviewItem = ReviewItem> = {
   prev: number | null
   next: number | null
   revision: string
-  counts: Record<string, number>
+  counts: Record<string, ReviewCount>
   facets: Record<string, ReviewFacet>
   section: { key: string; value: string; options: ReviewOption[] } | null
 }
@@ -129,12 +134,12 @@ export async function issuesReview(query: string | undefined, requestedPage: unk
   }
 }
 
-const byNewest = (a: any, b: any): number => String(b.ts ?? '').localeCompare(String(a.ts ?? ''))
+const byNewest = (a: any, b: any): number => Number(b.filterKind === EVAL_FILTER_KIND.RESULT) - Number(a.filterKind === EVAL_FILTER_KIND.RESULT)
+  || String(b.ts ?? '').localeCompare(String(a.ts ?? ''))
   || String(a.node ?? '').localeCompare(String(b.node ?? ''))
   || String(a.scenario ?? '').localeCompare(String(b.scenario ?? ''))
 
 export function trunkEvalReviewItems(nodes: any[]): ReviewItem[] {
-  const blind: any[] = []
   const items: any[] = []
   for (const node of nodes ?? []) {
     const latest = new Map<string, any>()
@@ -142,7 +147,7 @@ export function trunkEvalReviewItems(nodes: any[]): ReviewItem[] {
     for (const scenario of node.scenarios ?? []) {
       const reading = latest.get(scenario.name)
       if (!reading) {
-        blind.push({
+        items.push({
           scenario: scenario.name,
           expected: scenario.expected,
           tags: scenario.tags,
@@ -163,21 +168,18 @@ export function trunkEvalReviewItems(nodes: any[]): ReviewItem[] {
       })
     }
   }
-  blind.sort((a, b) => String(a.node).localeCompare(String(b.node)) || String(a.scenario).localeCompare(String(b.scenario)))
-  return [...blind, ...items.sort(byNewest)]
+  return items.sort(byNewest)
 }
 
 export function scopedEvalReviewItems(model: SessionEvals): ReviewItem[] {
-  const blind: any[] = []
-  const own: any[] = []
-  const inherited: any[] = []
+  const items: any[] = []
   for (const node of model.nodes ?? []) {
     const latest = new Map<string, any>()
     for (const reading of node.evals ?? []) if (!latest.has(reading.scenario)) latest.set(reading.scenario, reading)
     for (const scenario of node.scenarios ?? []) {
       const reading = latest.get(scenario.name)
       if (!reading) {
-        blind.push({
+        items.push({
           scenario: scenario.name,
           expected: scenario.expected,
           tags: scenario.tags,
@@ -192,15 +194,16 @@ export function scopedEvalReviewItems(model: SessionEvals): ReviewItem[] {
         ...reading,
         expected: scenario.expected ?? reading.expected,
         tags: scenario.tags,
+        impact: scenario.impact,
         state: evalReviewState(reading),
         node: node.id,
         hue: node.hue,
         filterKind: EVAL_FILTER_KIND.RESULT,
       }
-      ;(reading.inSession ? own : inherited).push(item)
+      items.push(item)
     }
   }
-  return [...blind, ...own.sort(byNewest), ...inherited.sort(byNewest)]
+  return items.sort(byNewest)
 }
 
 const evalItemKey = (item: any): string => `${String(item?.node ?? '')}\0${String(item?.scenario ?? '')}`
@@ -327,9 +330,10 @@ export async function evalsReview(query: string | undefined, requestedPage: unkn
       unknown: model.nodes.reduce((count, node) => count + (node.unknownCoverage?.length ?? 0), 0),
       summary: model.summary,
       evalRevision: model.evalRevision,
+      impact: model.impact,
       ...paginateReview(items, filtered.shown, filtered, requestedPage, {
         domain: 'evals', scope, items, gates: model.gates, summary: model.summary,
-        evalRevision: model.evalRevision, sessions: sessions.map((session) => session.id),
+        evalRevision: model.evalRevision, impact: model.impact, sessions: sessions.map((session) => session.id),
       }),
     }
   }

package/spec-cli/src/runtime-ownership.ts

@@ -0,0 +1,88 @@
+import { randomUUID } from 'node:crypto'
+import { spawn } from 'node:child_process'
+import { closeSync, mkdirSync, openSync, readdirSync, renameSync, rmSync, writeFileSync } from 'node:fs'
+import { dirname, join } from 'node:path'
+import { repoRoot } from './git.js'
+import { readJsonConfig, runtimeRoot } from './layout.js'
+import { processStartToken, writeDetachedRuntimeReceipt, type ProcessIdentity } from './process-identity.js'
+
+export type BackendInstanceRecord = {
+  version: 1
+  instanceId: string
+  pid: number
+  startToken: string
+  projectRoot: string
+  startedAt: string
+}
+
+const backendInstancesDir = () => join(runtimeRoot(), 'backend-instances')
+const backendInstancePath = (instanceId: string) => join(backendInstancesDir(), `${instanceId}.json`)
+
+const atomicJson = (path: string, value: unknown) => {
+  mkdirSync(dirname(path), { recursive: true })
+  const tmp = `${path}.${process.pid}.${randomUUID()}.tmp`
+  writeFileSync(tmp, `${JSON.stringify(value, null, 2)}\n`, { mode: 0o600 })
+  renameSync(tmp, path)
+}
+
+export function readBackendInstanceRecords(root = repoRoot()): BackendInstanceRecord[] {
+  let names: string[]
+  try { names = readdirSync(backendInstancesDir()) } catch { return [] }
+  return names.flatMap((name) => {
+    try {
+      const rec = readJsonConfig(join(backendInstancesDir(), name)) as BackendInstanceRecord
+      return rec?.version === 1 && rec.projectRoot === root ? [rec] : []
+    } catch { return [] }
+  })
+}
+
+export function registerBackendInstance(instanceId: string, pid = process.pid, root = repoRoot()): BackendInstanceRecord {
+  const startToken = processStartToken(pid)
+  if (!startToken) throw new Error(`cannot identify backend supervisor PID ${pid}`)
+  const record: BackendInstanceRecord = { version: 1, instanceId, pid, startToken, projectRoot: root, startedAt: new Date().toISOString() }
+  atomicJson(backendInstancePath(instanceId), record)
+  return record
+}
+
+export function unregisterBackendInstance(instanceId: string, pid = process.pid): void {
+  try {
+    const record = readJsonConfig(backendInstancePath(instanceId)) as BackendInstanceRecord
+    if (record.instanceId === instanceId && record.pid === pid && record.startToken === processStartToken(pid)) rmSync(backendInstancePath(instanceId), { force: true })
+  } catch { /* not ours / already removed */ }
+}
+
+export function spawnDetachedRuntime(opts: {
+  cwd: string
+  logFile: string
+  pidFile: string
+  receiptFile: string
+  command: string
+  args: string[]
+  env?: NodeJS.ProcessEnv
+}): ProcessIdentity {
+  mkdirSync(dirname(opts.logFile), { recursive: true })
+  mkdirSync(dirname(opts.pidFile), { recursive: true })
+  const log = openSync(opts.logFile, 'a', 0o600)
+  let child: ReturnType<typeof spawn>
+  try {
+    child = spawn(opts.command, opts.args, {
+      cwd: opts.cwd,
+      env: opts.env ?? process.env,
+      detached: true,
+      stdio: ['ignore', log, log],
+    })
+  } finally { closeSync(log) }
+  child.once('error', () => {})
+  if (!child.pid) throw new Error(`could not spawn detached shared runtime: ${opts.command}`)
+  child.unref()
+  try {
+    const identity = writeDetachedRuntimeReceipt(child.pid, opts.receiptFile)
+    writeFileSync(opts.pidFile, `${child.pid}\n`, { mode: 0o600 })
+    return { pid: identity.pid, startToken: identity.startToken }
+  } catch (error) {
+    try { child.kill('SIGTERM') } catch { /* exact just-spawned child already exited */ }
+    rmSync(opts.pidFile, { force: true })
+    rmSync(opts.receiptFile, { force: true })
+    throw error
+  }
+}