@gotcos/glasses-server 6.29.0 → 6.31.0

package/CHANGELOG.md

@@ -2219,6 +2219,75 @@ unsaved capture, and makes batch status stop lying about finished work.
 
 # Changelog
 
+## [6.31.0] - 2026-08-16
+
+### "Running" meant an open window, not a working agent
+
+- `GET /api/agent-sessions` adds **`running_active`**: the thread's transcript was
+  written in the last 30 seconds, so an agent is generating in it right now.
+- This exists because `running` could not answer that question and was being read
+  as though it could. It comes from a process registry, and a Claude Code record
+  describes an open WINDOW (`kind: interactive`, `entrypoint: claude-desktop`) —
+  so a session that finished an hour ago, with the window still up, stayed
+  `running: true` forever. A finished session reported itself active on the
+  glasses and never cleared.
+- The transcript is the only part of a session with a clock in it. While a
+  session generates, its jsonl mtime tracks the wall clock to within a second;
+  when it stops, the mtime goes stale while the registry record does not. That
+  divergence is the whole signal.
+- The window is 30 seconds, deliberately much wider than the observed write
+  cadence, so a long tool call between writes does not flap a working session to
+  idle and back.
+- **Costs one stat per HELD thread, not per listed thread.** Freshness is layered
+  on after the occupancy scan and only over what it found, so a list with nothing
+  running does no extra filesystem work at all.
+- Anything unmeasurable — no transcript, unreadable file, a timestamp from the
+  future — reads as NOT active. The row then falls back to "open", which is still
+  true of a thread with a live owner. The stronger claim has to be earned by an
+  actual observation.
+- **Still a display hint and still never a write gate.** `attachability` and
+  `attach` keep probing at the moment of the write, unchanged.
+
+### The session detail describes its own liveness
+
+- `GET /api/agent-sessions/:provider/:sessionId` now carries the same three
+  `running_*` fields plus `running_stamped: true` and `runningDegraded`.
+- Until now only the LIST stamped occupancy, so the detail page had to borrow the
+  flags from whichever row the user tapped. Those flags froze at the moment of the
+  tap, which is the other half of why a finished session never cleared: the page
+  had no way to ask again. A polling client needs a payload that carries its own
+  liveness.
+- `running_stamped` exists so a client can tell an old server's silence from a new
+  server's `false`. They demand opposite behaviour: keep the borrowed hint, or drop
+  it as stale.
+- Nearly free: the handler already resolves and stats the transcript, so only the
+  single-thread occupancy scan is new, and that is the same scan `attachability`
+  runs on every menu open.
+
+**Required by the COS Glasses build that ships the honest activity line.**
+
+## [6.30.0] - 2026-08-16
+
+### Sessions know which threads are live
+
+- `GET /api/agent-sessions` now stamps each row with `running` (an agent is
+  working in this thread right now) and `running_foreign` (it is held by
+  something that is not COS, so a Continue would be refused), plus a
+  `runningDegraded` flag on the payload when a probe could not see clearly.
+- `running` counts COS's own queued turn too. Two different questions: whether an
+  agent is working (the badge) and whether a write would be refused (the
+  affordance). Counting only foreign owners would hide your own turn from the
+  screen you open to watch it.
+- **This is a display hint and never a write gate.** Attach and turn keep probing
+  at the moment of the write, unchanged, so a desktop session opened between the
+  list render and the tap is still caught.
+- Fails the opposite way to the gate: doubt reports `degraded` rather than
+  painting every session busy.
+- One scan for the whole page, measured at 7ms for 45 real sessions (was 792ms
+  before a scan-scoped memo and skipping lsof when no Codex writer lock exists).
+
+**Required by COS Glasses 6.8.364.**
+
 ## [6.29.0] - 2026-08-16
 
 ### Continue is queued instead of holding the phone

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gotcos/glasses-server",
-  "version": "6.29.0",
+  "version": "6.31.0",
   "description": "COS Glasses \u2014 self-hosted AI heads-up-display server for Even G2 smart glasses, powered by Claude Code, Codex, or Cursor Agent CLI",
   "type": "module",
   "bin": {

package/server/lib/occupied-threads.ts

@@ -0,0 +1,285 @@
+// Which threads currently have a live desktop process, in ONE pass.
+//
+// WHY THIS EXISTS SEPARATELY FROM `threadOccupancy`.
+//
+// `claudeOwners(threadId, ...)` re-reads the whole session registry and shells
+// out to `ps` per entry, for ONE thread. That is correct and cheap when a user is
+// deciding whether to write into a single thread. Calling it once per row to
+// decorate a 53-row session list would mean tens of directory scans and hundreds
+// of process spawns on every list request.
+//
+// So this does the opposite shape: scan once, return the set of occupied ids, and
+// let the caller join in memory.
+//
+// THE LOAD-BEARING RULE, AND THE REASON THIS IS SAFE:
+//
+//   WHAT THIS PRODUCES IS A DISPLAY HINT. IT MUST NEVER GATE A WRITE.
+//
+// The attach and turn paths keep calling `threadOccupancy` at the moment of the
+// write, unchanged. That is deliberate: a list is rendered seconds or minutes
+// before the user acts, and a desktop session opened in that gap is exactly the
+// race the per-write probe exists to catch. This hint answers "should the UI show
+// this session as busy", never "is it safe to write".
+//
+// Being a hint is also why its failure mode is the opposite of the gate's. The
+// gate fails CLOSED — doubt means refuse. A hint that failed closed would paint
+// every session as running the moment a probe hiccuped, so doubt here means "I do
+// not know", rendered as not-running, and the real gate still refuses at the
+// write. Getting a hint wrong costs a misleading badge; getting the gate wrong
+// costs someone's conversation.
+
+import {
+  claudeOwners,
+  codexLockPath,
+  codexOwners,
+  type OccupancyDirs,
+  type OccupancyProbes,
+  type ThreadOwner,
+} from './thread-occupancy.js'
+import { isValidNativeThreadId } from './native-thread-id.js'
+
+export interface OccupiedThread {
+  threadId: string
+  /**
+   * Every process holding this thread open, COS's own children included.
+   *
+   * WHAT THIS ACTUALLY MEASURES, stated plainly because the first version of the
+   * feature got it wrong in user-facing copy: a registry record means A PROCESS
+   * HOLDS THIS THREAD OPEN. It does NOT mean an agent is generating. A Claude
+   * Code record reads `kind: interactive, entrypoint: claude-desktop` for an open
+   * WINDOW, so a session that finished ten minutes ago with the window still up
+   * has an owner forever. The lens said "ACTIVE NOW" off this number and was
+   * lying; it now says the thread is OPEN, which is all this count can support.
+   */
+  owners: number
+  /**
+   * Owners that are NOT COS's own children.
+   *
+   * The separate count matters because it answers a different question: whether a
+   * Continue would be refused. Self-owned work does not block a write; a desktop
+   * window does.
+   */
+  foreignOwners: number
+  /**
+   * The transcript was WRITTEN inside the freshness window: an agent is
+   * generating here, not merely holding the file open.
+   *
+   * This is the signal `owners` cannot give. Set only from a positive
+   * observation of a recent write — see `withActiveRecently`, which is where it
+   * is filled in. `occupiedThreads` itself has no path to a transcript and
+   * always leaves it false.
+   */
+  activeRecently: boolean
+}
+
+export interface OccupiedScan {
+  /** threadId -> occupancy, for every thread with at least one owner. */
+  occupied: Map<string, OccupiedThread>
+  /**
+   * True when the scan could not see clearly (unreadable registry, missing
+   * detector). The caller should render "unknown", never "everything is running".
+   */
+  degraded: boolean
+}
+
+const EMPTY: OccupiedScan = { occupied: new Map(), degraded: true }
+
+/**
+ * Probes that answer each identical question once per scan.
+ *
+ * MEASURED, not assumed. `claudeOwners` re-reads the whole registry directory and
+ * re-runs `ps` for every entry, for ONE thread — so scanning 45 real sessions on
+ * this machine cost 771ms of repeated identical I/O. With this wrapper the same
+ * scan is one directory read, one read per entry, and one `ps` per pid.
+ *
+ * Correctness comes from reusing `claudeOwners` / `codexOwners` UNCHANGED, so the
+ * self-ownership rule and the PID-reuse guard stay in exactly one place. This only
+ * removes duplicate work; it makes no decisions.
+ *
+ * Scoped to a single scan on purpose. A longer-lived cache would answer "is a
+ * desktop process holding this thread" from stale data, and liveness has a
+ * lifetime of about now.
+ */
+function memoize(probes: OccupancyProbes): OccupancyProbes {
+  const dirs = new Map<string, string[]>()
+  const files = new Map<string, string | null>()
+  const starts = new Map<number, number | null>()
+  const alive = new Map<number, boolean>()
+  const exists = new Map<string, boolean>()
+  const dirsExist = new Map<string, boolean>()
+  let ledger: ReturnType<OccupancyProbes['cosSpawnedPids']> | undefined
+
+  const once = <K, V>(cache: Map<K, V>, key: K, compute: () => V): V => {
+    if (cache.has(key)) return cache.get(key)!
+    const value = compute()
+    cache.set(key, value)
+    return value
+  }
+
+  return {
+    ...probes,
+    readDir: (path: string) => once(dirs, path, () => probes.readDir(path)),
+    readFile: (path: string) => once(files, path, () => probes.readFile(path)),
+    processStartMs: (pid: number) => once(starts, pid, () => probes.processStartMs(pid)),
+    isAlive: (pid: number) => once(alive, pid, () => probes.isAlive(pid)),
+    fileExists: (path: string) => once(exists, path, () => probes.fileExists(path)),
+    dirExists: (path: string) => once(dirsExist, path, () => probes.dirExists(path)),
+    cosSpawnedPids: () => (ledger ??= probes.cosSpawnedPids()),
+  }
+}
+
+/**
+ * Scan one provider's registry once and return the threads a desktop process
+ * holds.
+ *
+ * Reuses `claudeOwners` / `codexOwners` rather than reimplementing the parsing,
+ * so the self-ownership rule (COS's own spawned children must not read as foreign
+ * owners) and the PID-reuse guard stay in exactly one place. Reuse alone would
+ * repeat the whole registry read per thread — `memoize` is what removes that, so
+ * the saving is real I/O rather than a claim in a comment.
+ */
+export function occupiedThreads(
+  provider: string,
+  threadIds: readonly string[],
+  probes: OccupancyProbes,
+  dirs: OccupancyDirs,
+): OccupiedScan {
+  if (provider !== 'claude' && provider !== 'codex') return { occupied: new Map(), degraded: false }
+
+  // Deduplicated and validated up front. An invalid id cannot match a record, and
+  // it also reaches a filesystem path in `codexLockPath`.
+  const ids = [...new Set(threadIds)].filter(isValidNativeThreadId)
+  if (ids.length === 0) return { occupied: new Map(), degraded: false }
+
+  // Every identical read answered once for the whole scan. See `memoize`.
+  const probe = memoize(probes)
+  const occupied = new Map<string, OccupiedThread>()
+  let degraded = false
+
+  for (const threadId of ids) {
+    // MEASURED: `codexOwners` reaches `lsof` even when no writer lock exists, and
+    // lsof costs ~45ms a call — 761ms across 17 codex threads on this machine,
+    // against zero locks on disk. A missing lock means no writer, which is the
+    // same conclusion lsof reaches the expensive way, so skip it.
+    //
+    // Only an explicit `false` skips. `fileExists` collapses absent with
+    // unreadable, and an unreadable lock must still go through the real check
+    // rather than being read as free.
+    if (provider === 'codex') {
+      let lockPresent = true
+      try {
+        lockPresent = probe.fileExists(codexLockPath(threadId, dirs.codexLocksDir))
+      } catch {
+        lockPresent = true
+      }
+      if (!lockPresent) continue
+    }
+
+    let owners: readonly ThreadOwner[]
+    let doubt: string | null
+    try {
+      const result = provider === 'claude'
+        ? claudeOwners(threadId, probe, dirs.claudeSessionsDir)
+        : codexOwners(threadId, probe, dirs.codexLocksDir)
+      owners = result.owners
+      doubt = result.doubt
+    } catch {
+      // One thread's probe throwing does not invalidate the others.
+      degraded = true
+      continue
+    }
+    if (doubt !== null) degraded = true
+    // ANY owner means an agent is working here. Counting only foreign ones would
+    // hide COS's own queued turn from the very screen the user opens to watch it.
+    const foreign = owners.filter(o => !o.selfOwned).length
+    if (owners.length > 0) {
+      // `activeRecently` is FALSE here and can only be raised by
+      // `withActiveRecently`. This function reads a process registry; a registry
+      // record cannot tell generating from idling, and inferring one from the
+      // other is the exact defect this field exists to fix.
+      occupied.set(threadId, { threadId, owners: owners.length, foreignOwners: foreign, activeRecently: false })
+    }
+  }
+
+  return { occupied, degraded }
+}
+
+/** The safe answer when the caller cannot scan at all. */
+export function noOccupancyKnown(): OccupiedScan {
+  return { occupied: new Map(EMPTY.occupied), degraded: true }
+}
+
+/**
+ * How recently the transcript must have been written for a held thread to read
+ * as WORKING rather than merely OPEN.
+ *
+ * WHY A SECOND SIGNAL EXISTS AT ALL. `owners` answers "a process holds this
+ * thread", which is not the question the user is asking when he looks at the
+ * lens. He watched a session finish on his Mac while the glasses still showed it
+ * active, because the window was still open and the registry record therefore
+ * still existed. Occupancy has no clock in it; the transcript does.
+ *
+ * MEASURED, not assumed: while a session generates, its jsonl mtime tracks the
+ * wall clock to within a second, and when generation stops the mtime goes stale
+ * while the registry record stays exactly where it was. That divergence is the
+ * whole signal.
+ *
+ * 30 seconds is deliberately far wider than the observed sub-second write
+ * cadence. The gap this has to survive is a long tool call or a slow first token
+ * between writes, and a window sized to the cadence would flap a working session
+ * to OPEN and back every time the model paused to think. The cost of the wide
+ * window is bounded and known: a session that stops is reported working for up
+ * to 30 more seconds, which is a late correction rather than a permanent lie.
+ */
+export const ACTIVE_RECENTLY_WINDOW_MS = 30_000
+
+/**
+ * Was this transcript written inside the window?
+ *
+ * NULL IS NOT "RECENT". An unresolvable path, an unreadable file, a stat that
+ * threw — every one of them arrives here as null and answers false, so the row
+ * falls back to OPEN. That is not a fail-open: OPEN is still a true statement
+ * about a thread with a live owner. It is the STRONGER claim, "an agent is
+ * working in here", that has to be earned by an actual observation.
+ *
+ * A timestamp far in the FUTURE is refused for the same reason rather than
+ * treated as maximally fresh. Skew of a few seconds is normal and lands inside
+ * the window; a file dated next week is a clock this server cannot reason about,
+ * and letting it manufacture a permanent "working" badge would rebuild the bug
+ * from the other direction.
+ */
+export function isActiveRecently(mtimeMs: number | null | undefined, nowMs: number): boolean {
+  if (typeof mtimeMs !== 'number' || !Number.isFinite(mtimeMs)) return false
+  if (!Number.isFinite(nowMs)) return false
+  return Math.abs(nowMs - mtimeMs) <= ACTIVE_RECENTLY_WINDOW_MS
+}
+
+/**
+ * Fill in `activeRecently` for a scan, from transcript write times.
+ *
+ * PURE, and separate from `occupiedThreads` on purpose. Resolving a thread id to
+ * a transcript path is the session STORE's job (it owns the projects/rollouts
+ * layout), and this module owns process occupancy; wiring the store in here
+ * would make an occupancy scan depend on a filesystem it does not otherwise know
+ * about. The caller stats — for HELD THREADS ONLY, which is what keeps this
+ * cheap, since it is one stat per already-occupied row and never one per listed
+ * row — and hands the readings in.
+ *
+ * A thread with no entry in the map is not an error and not "recent": it reads
+ * exactly like an unreadable one, because from here the two are the same
+ * absence of evidence.
+ */
+export function withActiveRecently(
+  scan: OccupiedScan,
+  transcriptMtimes: ReadonlyMap<string, number | null>,
+  nowMs: number,
+): OccupiedScan {
+  const occupied = new Map<string, OccupiedThread>()
+  for (const [threadId, record] of scan.occupied) {
+    occupied.set(threadId, {
+      ...record,
+      activeRecently: isActiveRecently(transcriptMtimes.get(threadId), nowMs),
+    })
+  }
+  return { occupied, degraded: scan.degraded }
+}

package/server/routes/agent-sessions.ts

@@ -32,6 +32,15 @@ import {
 import { searchAgentSessions, type AgentSessionSearchHit } from '../lib/agent-session-search.js'
 import { claudeSessionNamesVisible, claudeSessionsDir, claudeSessionsEnabled, readClaudePeers } from './claude-sessions.js'
 import { workspaceFromCwd } from '../lib/claude-session-registry.js'
+import {
+  occupiedThreads,
+  noOccupancyKnown,
+  withActiveRecently,
+  type OccupiedScan,
+  type OccupiedThread,
+} from '../lib/occupied-threads.js'
+import { realOccupancyDirs, realOccupancyProbes } from '../lib/occupancy-probes.js'
+import { cosSpawnedPids } from '../lib/agent-session-ownership-store.js'
 
 export const agentSessionsRouter = Router()
 
@@ -61,6 +70,159 @@ function toSearchHit(row: AgentSessionSearchHit) {
   }
 }
 
+/**
+ * Which of these sessions a desktop process is holding right now.
+ *
+ * ONE scan for the whole page. Calling `threadOccupancy` per row would re-read the
+ * registry and shell out to `ps` per entry, which at 53 sessions is hundreds of
+ * process spawns on a single list request.
+ *
+ * THIS IS A DISPLAY HINT AND MUST NEVER GATE A WRITE. The attach and turn routes
+ * keep probing at the moment of the write, unchanged, because a list is rendered
+ * seconds or minutes before the user acts and a desktop session opened in that gap
+ * is exactly the race the per-write probe exists to catch.
+ */
+function runningThreads(rows: readonly AgentSessionRow[]): OccupiedScan {
+  try {
+    const dirs = realOccupancyDirs()
+    // The spawn ledger is what lets a turn COS itself queued read as ours rather
+    // than as a foreign desktop window holding the thread.
+    const probes = realOccupancyProbes(cosSpawnedPids)
+    const byProvider = new Map<string, string[]>()
+    for (const row of rows) {
+      if (row.provider !== 'claude' && row.provider !== 'codex') continue
+      const list = byProvider.get(row.provider) ?? []
+      list.push(row.session_id)
+      byProvider.set(row.provider, list)
+    }
+    const merged = new Map<string, OccupiedThread>()
+    let degraded = false
+    for (const [provider, ids] of byProvider) {
+      const scan = occupiedThreads(provider, ids, probes, dirs)
+      for (const [id, occ] of scan.occupied) merged.set(id, occ)
+      if (scan.degraded) degraded = true
+    }
+    return { occupied: merged, degraded }
+  } catch (error) {
+    // The list is the point; occupancy is decoration. A probe failure must never
+    // cost the user their sessions.
+    console.error(`[agent-sessions] occupancy scan failed: ${error instanceof Error ? error.message : error}`)
+    return noOccupancyKnown()
+  }
+}
+
+/**
+ * When each HELD thread's transcript was last written.
+ *
+ * ONLY the threads the scan already found occupied. That is the entire cost
+ * argument: the occupied set is typically one or two rows out of sixty, so this
+ * is one or two path resolutions and stats per request, not sixty. An empty scan
+ * does no filesystem work at all.
+ *
+ * WHY NOT REUSE `row.modified`, WHICH IS ALREADY AN MTIME. Because for the rows
+ * that matter it is not one. A live Claude row comes from `liveClaudeRows`,
+ * whose `modified` is the registry's `lastActiveAt` (or, absent that, literally
+ * `new Date()`), and `enrichLiveClaude` does not replace it with the file's
+ * mtime. Reading freshness off that field would report an open window as a fresh
+ * write on every single request, which is precisely the bug being fixed.
+ *
+ * Every failure lands on null, and null is doubt rather than "recent" — see
+ * `isActiveRecently`. A row that cannot be measured reads OPEN, which is still
+ * true of a thread with a live owner.
+ */
+async function transcriptMtimes(
+  scan: OccupiedScan,
+  rows: readonly AgentSessionRow[],
+): Promise<Map<string, number | null>> {
+  const mtimes = new Map<string, number | null>()
+  if (scan.occupied.size === 0) return mtimes
+
+  const providerById = new Map<string, AgentProvider>()
+  for (const row of rows) providerById.set(row.session_id, row.provider)
+  const roots = agentSessionRoots()
+
+  await Promise.all([...scan.occupied.keys()].map(async threadId => {
+    try {
+      const provider = providerById.get(threadId)
+      // An occupied id with no row cannot happen today (the scan is built FROM
+      // the rows), but guessing a provider to go looking for a file is how a
+      // caller-supplied id reaches the filesystem. Unknown stays unmeasured.
+      if (!provider) {
+        mtimes.set(threadId, null)
+        return
+      }
+      const file = await findAgentSessionFile(provider, threadId, roots)
+      mtimes.set(threadId, file ? (await stat(file)).mtimeMs : null)
+    } catch {
+      mtimes.set(threadId, null)
+    }
+  }))
+  return mtimes
+}
+
+/**
+ * Stamp the running hint onto a projected row.
+ *
+ * EXPORTED so the WIRE KEYS are covered by a behaviour test rather than by
+ * reading this file. The client reads `running_active` by exact name
+ * (`session-running.ts` accepts only a literal `true` on a known key), so a
+ * rename here is silent on this side and renders every session as merely open on
+ * the lens. Pure: it takes the scan, it does no I/O.
+ */
+export function withRunning<T extends { session_id: string }>(entry: T, scan: OccupiedScan) {
+  const occ = scan.occupied.get(entry.session_id)
+  return {
+    ...entry,
+    // A process HOLDS this thread open, whoever started it. Not "is generating":
+    // a Claude record for an open window outlives the work by however long the
+    // window stays up, which is why `running_active` exists below.
+    running: occ !== undefined,
+    // Held by something that is not COS, so a Continue would be refused. The
+    // badge reads `running`; the Continue affordance reads this.
+    running_foreign: (occ?.foreignOwners ?? 0) > 0,
+    // The transcript was WRITTEN in the last few seconds: an agent is generating
+    // here, not just holding the file. This is the only one of the three that
+    // clears on its own when the work stops. Still a display hint, never a gate.
+    running_active: occ?.activeRecently === true,
+  }
+}
+
+/**
+ * Occupancy plus freshness for ONE thread, for the detail route.
+ *
+ * WHY THE DETAIL ROUTE STAMPS THIS AT ALL. It did not, and the lens had to borrow
+ * the hint from whichever list row the user tapped. That worked exactly once: the
+ * detail page was a single fetch, so the borrowed flags were frozen at the moment
+ * it opened and could never clear, which is half of why a finished session stayed
+ * "active" on the glasses until Miles navigated away. A page that polls needs a
+ * payload that carries its own liveness.
+ *
+ * NEARLY FREE HERE. The handler has already resolved the transcript path and
+ * stat'ed it, so freshness costs nothing extra and only the single-thread
+ * occupancy scan is new — the same scan `attachability` already runs on every
+ * menu open. Contrast the list, where the same work would be sixty scans.
+ *
+ * STILL A DISPLAY HINT. Nothing about being on the detail payload makes it a
+ * gate; `attach` re-probes at the write, unchanged.
+ */
+function runningForThread(provider: AgentProvider, threadId: string, mtimeMs: number): OccupiedScan {
+  if (provider !== 'claude' && provider !== 'codex') return { occupied: new Map(), degraded: false }
+  try {
+    const scan = occupiedThreads(
+      provider,
+      [threadId],
+      realOccupancyProbes(cosSpawnedPids),
+      realOccupancyDirs(),
+    )
+    return withActiveRecently(scan, new Map([[threadId, mtimeMs]]), Date.now())
+  } catch (error) {
+    // The transcript is the point; occupancy is decoration. A probe failure must
+    // never cost the user their session.
+    console.error(`[agent-sessions] detail occupancy failed: ${error instanceof Error ? error.message : error}`)
+    return noOccupancyKnown()
+  }
+}
+
 function toEntry(row: AgentSessionRow) {
   return {
     session_id: row.session_id,
@@ -107,12 +269,20 @@ agentSessionsRouter.get('/agent-sessions', async (req, res) => {
     const sort = asSort(req.query.sort)
     const live = await liveClaudeRows()
     const sessions = await listAgentSessions(agentSessionRoots(), new Date(), live, limit, sort)
+    const scan = runningThreads(sessions)
+    // Freshness is layered on AFTER occupancy, and only over what occupancy
+    // found. `Date.now()` is read once so every row in a payload is judged
+    // against the same instant.
+    const running = withActiveRecently(scan, await transcriptMtimes(scan, sessions), Date.now())
     res.json({
-      sessions: sessions.map(toEntry),
+      sessions: sessions.map(row => withRunning(toEntry(row), running)),
       total: sessions.length,
       windowHours: AGENT_SESSION_WINDOW_HOURS,
       sort,
       enabled: true,
+      // True when a probe could not see clearly. The client must render "unknown"
+      // rather than treating a quiet scan as "nothing is running".
+      runningDegraded: running.degraded,
     })
   } catch (error) {
     console.error(`[agent-sessions] list failed: ${error instanceof Error ? error.message : error}`)
@@ -173,8 +343,19 @@ agentSessionsRouter.get('/agent-sessions/:provider/:sessionId', async (req, res)
       if (named) parsed.display_label = named
     }
     const modified = st.mtime.toISOString()
+    const running = runningForThread(provider, parsed.session_id, st.mtimeMs)
     res.json({
-      session_id: parsed.session_id,
+      ...withRunning({ session_id: parsed.session_id }, running),
+      // The client must be able to tell "this server stamped nothing" from "this
+      // server stamped false", because the two demand opposite behaviour: an old
+      // server's silence means keep using the hint borrowed from the list row, and
+      // a new server's `false` means the thread genuinely went quiet and the
+      // borrowed hint is the stale thing. Without this marker the poll could never
+      // clear the flag it exists to clear.
+      running_stamped: true,
+      // Same meaning as on the list: a probe could not see clearly, so render
+      // unknown rather than treating a quiet scan as "nothing is running".
+      runningDegraded: running.degraded,
       provider: parsed.provider,
       slug: parsed.session_id,
       custom_title: parsed.display_label,