@threadcrumbs/common 0.1.9 → 0.1.11

package/lib/claude-transcript.mjs

@@ -2,6 +2,7 @@ import fsp from 'node:fs/promises'
 import { requestCost } from './anthropic-prices.mjs'
 import { FIXED_PARTS, emptyFixed, emptySizes, setFixed, sizeCall, sizeCompaction, sizePrompt, sizeReply, sizeRequest, sizeResult, sizeResumed } from './context-breakdown.mjs'
 import { listFiles, parseJsonLine, readNewLines } from './fsutil.mjs'
+import { reusedPids } from './proc-start.mjs'
 import {
   DETAIL_LIMITS,
   activityDetail,
@@ -60,8 +61,9 @@ const pidAlive = (pid) => {
   }
 }
 
-export async function readLiveSessions(dir, isAlive = pidAlive) {
-  const live = new Map()
+export async function readLiveSessions(dir, isAlive = pidAlive, reused = reusedPids) {
+  const records = []
+  const dead = []
   for (const file of await listFiles(dir, (n) => n.endsWith('.json'))) {
     let record
     try {
@@ -69,7 +71,19 @@ export async function readLiveSessions(dir, isAlive = pidAlive) {
     } catch {
       continue
     }
-    if (!record?.sessionId || !record.pid || !isAlive(record.pid)) continue
+    if (!record?.sessionId || !record.pid) continue
+    if (isAlive(record.pid)) records.push(record)
+    else dead.push(record.pid)
+  }
+  try {
+    reused?.forget?.(dead)
+  } catch {}
+  const recycled = await Promise.resolve()
+    .then(() => reused(records))
+    .catch(() => null)
+  const live = new Map()
+  for (const record of records) {
+    if (recycled instanceof Set && recycled.has(record.pid)) continue
     live.set(record.sessionId, { pid: record.pid, status: text(record.status), name: text(record.name), socket: text(record.messagingSocketPath) })
   }
   return live

package/lib/proc-start.mjs

@@ -0,0 +1,157 @@
+import { execFile } from 'node:child_process'
+import fsp from 'node:fs/promises'
+import os from 'node:os'
+import path from 'node:path'
+
+const WAIT_MS = 1000
+const QUERY_MS = 10_000
+const KEPT = 1024
+const USER_HZ = 100
+const LSTART_SLACK_S = 60
+const FILETIME_MAX = 300_000_000_000_000_000n
+const TICKS_BEFORE_1601 = 504_911_232_000_000_000n
+const QUARTER_HOUR = 9_000_000_000n
+const TICK_SLACK = 10n
+const PS = '/bin/ps'
+
+const powershell = () => path.win32.join(process.env.SystemRoot || 'C:\\Windows', 'System32', 'WindowsPowerShell', 'v1.0', 'powershell.exe')
+
+const getProcess = (pids) =>
+  `$ErrorActionPreference='SilentlyContinue';foreach($p in Get-Process -Id ${pids.join(',')}){try{'{0} {1}' -f $p.Id,$p.StartTime.ToFileTimeUtc()}catch{}}`
+
+function query(file, args, env = {}) {
+  return new Promise((resolve) => {
+    execFile(file, args, { env: { ...process.env, ...env }, timeout: QUERY_MS, windowsHide: true }, (err, stdout) => resolve(typeof stdout === 'string' ? stdout : ''))
+  })
+}
+
+function startLines(stdout, line) {
+  const found = new Map()
+  for (const row of stdout.slice(0, stdout.lastIndexOf('\n') + 1).split('\n')) {
+    const m = line.exec(row)
+    if (m) found.set(Number(m[1]), m[2])
+  }
+  return found
+}
+
+const lstartSeconds = (value) => Date.parse(`${value} UTC`) / 1000
+
+const statTicks = (stat) => stat.slice(stat.lastIndexOf(')') + 2).split(' ')[19]
+
+async function linuxStarts(pids, read) {
+  const boot = Number(/^btime (\d+)$/m.exec(await read('/proc/stat', 'utf8').catch(() => ''))?.[1])
+  const found = new Map()
+  for (const pid of pids) {
+    const ticks = statTicks((await read(`/proc/${pid}/stat`, 'utf8').catch(() => '')) || '')
+    if (!/^\d+$/.test(ticks || '')) continue
+    found.set(pid, { ticks, seconds: boot > 0 ? boot + Math.floor(Number(ticks) / USER_HZ) : NaN })
+  }
+  return found
+}
+
+export async function processStarts(pids, { platform = process.platform, run = query, read = fsp.readFile } = {}) {
+  const asked = [...new Set(pids)].filter((pid) => Number.isSafeInteger(pid) && pid > 0)
+  if (!asked.length) return new Map()
+  if (platform === 'linux') return linuxStarts(asked, read)
+  if (platform === 'win32') {
+    const found = startLines(await run(powershell(), ['-NoLogo', '-NoProfile', '-NonInteractive', '-Command', getProcess(asked)]), /^\s*(\d+)\s+(\d+)\s*$/)
+    return new Map([...found].map(([pid, filetime]) => [pid, { filetime }]))
+  }
+  if (platform === 'darwin') {
+    const found = startLines(await run(PS, ['-o', 'pid=', '-o', 'lstart=', '-p', asked.join(',')], { LC_ALL: 'C', TZ: 'UTC' }), /^\s*(\d+)\s+(\S.*?)\s*$/)
+    return new Map([...found].map(([pid, lstart]) => [pid, { seconds: lstartSeconds(lstart) }]))
+  }
+  return new Map()
+}
+
+function sameFiletime(recorded, actual) {
+  if (recorded <= FILETIME_MAX) return recorded === actual
+  const offset = (((recorded - TICKS_BEFORE_1601 - actual) % QUARTER_HOUR) + QUARTER_HOUR) % QUARTER_HOUR
+  return offset <= TICK_SLACK || QUARTER_HOUR - offset <= TICK_SLACK
+}
+
+export function sameStart(recorded, found) {
+  if (typeof recorded !== 'string' || !found || typeof found !== 'object') return null
+  const value = recorded.trim()
+  if (/^\d+$/.test(value)) {
+    if (/^\d+$/.test(found.filetime ?? '')) return sameFiletime(BigInt(value), BigInt(found.filetime))
+    if (/^\d+$/.test(found.ticks ?? '')) return BigInt(value) === BigInt(found.ticks)
+    return null
+  }
+  const at = lstartSeconds(value)
+  if (!Number.isFinite(at) || !Number.isFinite(found.seconds)) return null
+  return Math.abs(at - found.seconds) <= LSTART_SLACK_S
+}
+
+async function domainOf(platform) {
+  if (platform === 'win32') return `win32:${os.hostname().toLowerCase()}`
+  if (platform === 'darwin') return 'darwin'
+  if (platform !== 'linux') return null
+  const [id, ns] = await Promise.all([
+    fsp.readFile('/etc/machine-id', 'utf8').then((t) => t.trim(), () => ''),
+    fsp.readlink('/proc/self/ns/pid').catch(() => ''),
+  ])
+  return `linux:${id}:${ns}`
+}
+
+const domains = new Map()
+
+export function ownPidDomain(platform = process.platform) {
+  if (!domains.has(platform)) domains.set(platform, domainOf(platform).catch(() => null))
+  return domains.get(platform)
+}
+
+const recordedStart = (record) => [record?.procStartFt, record?.procStart].find((v) => typeof v === 'string' && v.trim())?.trim() || ''
+
+function within(promise, ms) {
+  let timer
+  const late = new Promise((resolve) => {
+    timer = setTimeout(resolve, ms)
+  })
+  return Promise.race([promise, late]).finally(() => clearTimeout(timer))
+}
+
+export function reusedPidCheck({ lookup = processStarts, domain = ownPidDomain, waitMs = WAIT_MS } = {}) {
+  const known = new Map()
+  const forget = (pids) => {
+    const gone = new Set(pids)
+    if (!gone.size) return
+    for (const key of [...known.keys()]) if (gone.has(Number(key.slice(0, key.indexOf(':'))))) known.delete(key)
+  }
+  return Object.assign(reusedPids, { forget })
+  async function reusedPids(records) {
+    const own = await Promise.resolve()
+      .then(() => domain())
+      .catch(() => null)
+    if (!own) return new Set()
+    const asked = []
+    for (const record of records) {
+      const start = recordedStart(record)
+      const local = record?.pidDomain === undefined || record.pidDomain === own
+      if (start && local && Number.isSafeInteger(record.pid) && record.pid > 0) asked.push({ pid: record.pid, start, key: `${record.pid}:${start}` })
+    }
+    const fresh = asked.filter((a) => !known.has(a.key))
+    if (fresh.length) {
+      const found = Promise.resolve()
+        .then(() => lookup(fresh.map((a) => a.pid)))
+        .catch(() => null)
+      for (const a of fresh) {
+        const entry = { same: null, ready: null }
+        entry.ready = found
+          .then((starts) => sameStart(a.start, starts instanceof Map ? starts.get(a.pid) : undefined))
+          .catch(() => null)
+          .then((same) => {
+            entry.same = same
+            entry.ready = null
+          })
+        known.set(a.key, entry)
+        if (known.size > KEPT) known.delete(known.keys().next().value)
+      }
+    }
+    const waiting = asked.map((a) => known.get(a.key)?.ready).filter(Boolean)
+    if (waiting.length) await within(Promise.all(waiting), waitMs)
+    return new Set(asked.filter((a) => known.get(a.key)?.same === false).map((a) => a.pid))
+  }
+}
+
+export const reusedPids = reusedPidCheck()

package/license/store.mjs

@@ -1,155 +1,192 @@
-import { randomBytes } from 'node:crypto'
-import fsp from 'node:fs/promises'
-import os from 'node:os'
-import path from 'node:path'
-import { LICENSE_PUBLIC_KEYS, verifyLicense } from './index.mjs'
-
-const FILE = 'license.json'
-const DEVICE = /^[A-Za-z0-9_-]{8,100}$/
-const SEEN_STEP = 3600
-const READ_TRIES = 5
-const RENAME_TRIES = 10
-const PAUSE_MS = 20
-const CLOUD_URL = 'https://threadcrumbs.io/api'
-const LOCAL_CLOUD_URL = 'http://localhost:8787/api'
-
-const pause = () => new Promise((resolve) => setTimeout(resolve, PAUSE_MS))
-const isDevice = (value) => typeof value === 'string' && DEVICE.test(value)
-const finite = (value) => (typeof value === 'number' && Number.isFinite(value) ? value : 0)
-
-export function threadcrumbsDataDir({ platform = process.platform, env = process.env, home = os.homedir() } = {}) {
-  if (env.THREADCRUMBS_DATA_DIR) return env.THREADCRUMBS_DATA_DIR
-  if (platform === 'win32') {
-    return path.win32.join(env.APPDATA || path.win32.join(home, 'AppData', 'Roaming'), 'Threadcrumbs')
-  }
-  if (platform === 'darwin') return path.posix.join(home, 'Library', 'Application Support', 'Threadcrumbs')
-  const xdg = env.XDG_DATA_HOME && path.posix.isAbsolute(env.XDG_DATA_HOME) ? env.XDG_DATA_HOME : ''
-  return path.posix.join(xdg || path.posix.join(home, '.local', 'share'), 'threadcrumbs')
-}
-
-export function trustedKeys({ env = process.env, development = false } = {}) {
-  const extra = development ? env.THREADCRUMBS_LICENSE_KEYS : ''
-  if (!extra) return { ...LICENSE_PUBLIC_KEYS }
-  let parsed
-  try {
-    parsed = JSON.parse(extra)
-  } catch {
-    throw new Error('THREADCRUMBS_LICENSE_KEYS must be JSON: { "<kid>": "<public key>" }')
-  }
-  if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed) || !Object.values(parsed).every((k) => typeof k === 'string')) {
-    throw new Error('THREADCRUMBS_LICENSE_KEYS must map each key ID to a public key')
-  }
-  return { ...LICENSE_PUBLIC_KEYS, ...parsed }
-}
-
-export function cloudUrl({ env = process.env, development = false } = {}) {
-  return (env.THREADCRUMBS_CLOUD_URL || (development ? LOCAL_CLOUD_URL : CLOUD_URL)).replace(/\/+$/, '')
-}
-
-async function check(token, keys, device) {
-  try {
-    return await verifyLicense(token, { keys, device })
-  } catch {
-    return { ok: false, reason: 'malformed' }
-  }
-}
-
-export function licenseStore({ dir = threadcrumbsDataDir(), keys = LICENSE_PUBLIC_KEYS, now = () => Date.now() / 1000 } = {}) {
-  const file = path.join(dir, FILE)
-
-  async function read() {
-    let text
-    try {
-      text = await fsp.readFile(file, 'utf8')
-    } catch (err) {
-      if (err.code === 'ENOENT') return null
-      throw err
-    }
-    try {
-      const data = JSON.parse(text)
-      return data && typeof data === 'object' && !Array.isArray(data) ? data : {}
-    } catch {
-      return {}
-    }
-  }
-
-  const serialize = (data) => `${JSON.stringify(data, null, 2)}\n`
-
-  async function replace(data) {
-    await fsp.mkdir(dir, { recursive: true })
-    const temp = `${file}.${process.pid}.${randomBytes(4).toString('hex')}.tmp`
-    try {
-      await fsp.writeFile(temp, serialize(data), { mode: 0o600 })
-      for (let attempt = 1; ; attempt++) {
-        try {
-          return await fsp.rename(temp, file)
-        } catch (err) {
-          if (attempt >= RENAME_TRIES || !['EPERM', 'EACCES', 'EBUSY'].includes(err.code)) throw err
-          await pause()
-        }
-      }
-    } catch (err) {
-      await fsp.rm(temp, { force: true })
-      throw err
-    }
-  }
-
-  async function device() {
-    for (let attempt = 0; attempt < READ_TRIES; attempt++) {
-      const data = await read()
-      if (isDevice(data?.device)) return data.device
-      if (data === null) {
-        await fsp.mkdir(dir, { recursive: true })
-        try {
-          await fsp.writeFile(file, serialize({ device: randomBytes(18).toString('base64url'), license: null, seen: 0 }), { flag: 'wx', mode: 0o600 })
-        } catch (err) {
-          if (err.code !== 'EEXIST') throw err
-        }
-        continue
-      }
-      await pause()
-    }
-    await replace({ device: randomBytes(18).toString('base64url'), license: null, seen: 0 })
-    const data = await read()
-    if (!isDevice(data?.device)) throw new Error(`Can't read or replace ${file}`)
-    return data.device
-  }
-
-  async function update(change) {
-    const data = (await read()) ?? {}
-    await replace({ ...data, ...change, device: data.device })
-  }
-
-  async function current() {
-    const clock = now()
-    if ((await read()) === null) return { device: null, token: null, license: null, at: clock }
-    const dev = await device()
-    const data = (await read()) ?? {}
-    const seen = finite(data.seen)
-    if (typeof data.license !== 'string') return { device: dev, token: null, license: null, at: Math.max(clock, seen) }
-    const checked = await check(data.license, keys, dev)
-    if (!checked.ok) return { device: dev, token: null, license: null, reason: checked.reason, at: Math.max(clock, seen) }
-    if (clock > seen + SEEN_STEP) await update({ seen: clock }).catch(() => {})
-    return { device: dev, token: data.license, license: checked.license, at: Math.max(clock, seen, checked.license.iat) }
-  }
-
-  async function save(token) {
-    const dev = await device()
-    const checked = await check(token, keys, dev)
-    if (!checked.ok) return checked
-    const data = (await read()) ?? {}
-    const stored = typeof data.license === 'string' ? await check(data.license, keys, dev) : null
-    if (stored?.ok && stored.license.iat > checked.license.iat) {
-      return { ok: true, license: stored.license, at: Math.max(now(), finite(data.seen), stored.license.iat) }
-    }
-    await update({ license: token, seen: checked.license.iat })
-    return { ok: true, license: checked.license, at: Math.max(now(), checked.license.iat) }
-  }
-
-  async function clear() {
-    await device()
-    await update({ license: null })
-  }
-
-  return { file, device, current, save, clear }
-}
+import { randomBytes } from 'node:crypto'
+import fsp from 'node:fs/promises'
+import os from 'node:os'
+import path from 'node:path'
+import { LICENSE_PUBLIC_KEYS, verifyLicense } from './index.mjs'
+
+const FILE = 'license.json'
+const DEVICE = /^[A-Za-z0-9_-]{8,100}$/
+const SEEN_STEP = 3600
+const READ_TRIES = 5
+const RENAME_TRIES = 10
+const PAUSE_MS = 20
+const CLOUD_URL = 'https://threadcrumbs.io/api'
+const LOCAL_CLOUD_URL = 'http://localhost:8787/api'
+const CLOUD_TIMEOUT_MS = 15000
+
+const pause = () => new Promise((resolve) => setTimeout(resolve, PAUSE_MS))
+const isDevice = (value) => typeof value === 'string' && DEVICE.test(value)
+const finite = (value) => (typeof value === 'number' && Number.isFinite(value) ? value : 0)
+
+export function threadcrumbsDataDir({ platform = process.platform, env = process.env, home = os.homedir() } = {}) {
+  if (env.THREADCRUMBS_DATA_DIR) return env.THREADCRUMBS_DATA_DIR
+  if (platform === 'win32') {
+    return path.win32.join(env.APPDATA || path.win32.join(home, 'AppData', 'Roaming'), 'Threadcrumbs')
+  }
+  if (platform === 'darwin') return path.posix.join(home, 'Library', 'Application Support', 'Threadcrumbs')
+  const xdg = env.XDG_DATA_HOME && path.posix.isAbsolute(env.XDG_DATA_HOME) ? env.XDG_DATA_HOME : ''
+  return path.posix.join(xdg || path.posix.join(home, '.local', 'share'), 'threadcrumbs')
+}
+
+export function trustedKeys({ env = process.env, development = false } = {}) {
+  const extra = development ? env.THREADCRUMBS_LICENSE_KEYS : ''
+  if (!extra) return { ...LICENSE_PUBLIC_KEYS }
+  let parsed
+  try {
+    parsed = JSON.parse(extra)
+  } catch {
+    throw new Error('THREADCRUMBS_LICENSE_KEYS must be JSON: { "<kid>": "<public key>" }')
+  }
+  if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed) || !Object.values(parsed).every((k) => typeof k === 'string')) {
+    throw new Error('THREADCRUMBS_LICENSE_KEYS must map each key ID to a public key')
+  }
+  return { ...LICENSE_PUBLIC_KEYS, ...parsed }
+}
+
+export function cloudUrl({ env = process.env, development = false } = {}) {
+  return (env.THREADCRUMBS_CLOUD_URL || (development ? LOCAL_CLOUD_URL : CLOUD_URL)).replace(/\/+$/, '')
+}
+
+const PORTAL_REFUSALS = {
+  not_activated: 'Enter your license key on this computer first.',
+  offline: "Couldn't reach the license service. Check your connection, then try again.",
+  unavailable: "The license service didn't answer as expected. Try again in a minute.",
+}
+
+const refusal = (error) => ({ error, why: PORTAL_REFUSALS[error] })
+
+function isHttps(url) {
+  try {
+    return new URL(url).protocol === 'https:'
+  } catch {
+    return false
+  }
+}
+
+export async function portalUrl({ license, device, fetch = globalThis.fetch, cloud = cloudUrl() } = {}) {
+  if (typeof license !== 'string' || !license || !isDevice(device)) return refusal('not_activated')
+  if (!cloud) return refusal('unavailable')
+  let response
+  try {
+    response = await fetch(`${cloud}/v1/portal`, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ license, device }),
+      signal: AbortSignal.timeout(CLOUD_TIMEOUT_MS),
+    })
+  } catch {
+    return refusal('offline')
+  }
+  const data = await response.json().catch(() => null)
+  if (response.ok && typeof data?.url === 'string' && isHttps(data.url)) return { url: data.url }
+  if (!response.ok && typeof data?.error === 'string' && typeof data.why === 'string' && data.why) return { error: data.error, why: data.why }
+  return refusal('unavailable')
+}
+
+async function check(token, keys, device) {
+  try {
+    return await verifyLicense(token, { keys, device })
+  } catch {
+    return { ok: false, reason: 'malformed' }
+  }
+}
+
+export function licenseStore({ dir = threadcrumbsDataDir(), keys = LICENSE_PUBLIC_KEYS, now = () => Date.now() / 1000 } = {}) {
+  const file = path.join(dir, FILE)
+
+  async function read() {
+    let text
+    try {
+      text = await fsp.readFile(file, 'utf8')
+    } catch (err) {
+      if (err.code === 'ENOENT') return null
+      throw err
+    }
+    try {
+      const data = JSON.parse(text)
+      return data && typeof data === 'object' && !Array.isArray(data) ? data : {}
+    } catch {
+      return {}
+    }
+  }
+
+  const serialize = (data) => `${JSON.stringify(data, null, 2)}\n`
+
+  async function replace(data) {
+    await fsp.mkdir(dir, { recursive: true })
+    const temp = `${file}.${process.pid}.${randomBytes(4).toString('hex')}.tmp`
+    try {
+      await fsp.writeFile(temp, serialize(data), { mode: 0o600 })
+      for (let attempt = 1; ; attempt++) {
+        try {
+          return await fsp.rename(temp, file)
+        } catch (err) {
+          if (attempt >= RENAME_TRIES || !['EPERM', 'EACCES', 'EBUSY'].includes(err.code)) throw err
+          await pause()
+        }
+      }
+    } catch (err) {
+      await fsp.rm(temp, { force: true })
+      throw err
+    }
+  }
+
+  async function device() {
+    for (let attempt = 0; attempt < READ_TRIES; attempt++) {
+      const data = await read()
+      if (isDevice(data?.device)) return data.device
+      if (data === null) {
+        await fsp.mkdir(dir, { recursive: true })
+        try {
+          await fsp.writeFile(file, serialize({ device: randomBytes(18).toString('base64url'), license: null, seen: 0 }), { flag: 'wx', mode: 0o600 })
+        } catch (err) {
+          if (err.code !== 'EEXIST') throw err
+        }
+        continue
+      }
+      await pause()
+    }
+    await replace({ device: randomBytes(18).toString('base64url'), license: null, seen: 0 })
+    const data = await read()
+    if (!isDevice(data?.device)) throw new Error(`Can't read or replace ${file}`)
+    return data.device
+  }
+
+  async function update(change) {
+    const data = (await read()) ?? {}
+    await replace({ ...data, ...change, device: data.device })
+  }
+
+  async function current() {
+    const clock = now()
+    if ((await read()) === null) return { device: null, token: null, license: null, at: clock }
+    const dev = await device()
+    const data = (await read()) ?? {}
+    const seen = finite(data.seen)
+    if (typeof data.license !== 'string') return { device: dev, token: null, license: null, at: Math.max(clock, seen) }
+    const checked = await check(data.license, keys, dev)
+    if (!checked.ok) return { device: dev, token: null, license: null, reason: checked.reason, at: Math.max(clock, seen) }
+    if (clock > seen + SEEN_STEP) await update({ seen: clock }).catch(() => {})
+    return { device: dev, token: data.license, license: checked.license, at: Math.max(clock, seen, checked.license.iat) }
+  }
+
+  async function save(token) {
+    const dev = await device()
+    const checked = await check(token, keys, dev)
+    if (!checked.ok) return checked
+    const data = (await read()) ?? {}
+    const stored = typeof data.license === 'string' ? await check(data.license, keys, dev) : null
+    if (stored?.ok && stored.license.iat > checked.license.iat) {
+      return { ok: true, license: stored.license, at: Math.max(now(), finite(data.seen), stored.license.iat) }
+    }
+    await update({ license: token, seen: checked.license.iat })
+    return { ok: true, license: checked.license, at: Math.max(now(), checked.license.iat) }
+  }
+
+  async function clear() {
+    await device()
+    await update({ license: null })
+  }
+
+  return { file, device, current, save, clear }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@threadcrumbs/common",
-  "version": "0.1.9",
+  "version": "0.1.11",
   "type": "module",
   "description": "Code the Threadcrumbs apps share, starting with the readers for each coding-agent harness.",
   "license": "SEE LICENSE IN LICENSE.md",

package/telemetry/claude-code.mjs

@@ -24,6 +24,7 @@ export function claudeCode({
   desktop = claudeDesktopStores(),
   now = Date.now,
   isAlive,
+  reusedPids,
 } = {}) {
   const projectsDir = path.join(home, 'projects')
   const liveDir = path.join(home, 'sessions')
@@ -155,7 +156,7 @@ export function claudeCode({
   }
 
   async function scanSessions() {
-    const [live, limits, marks] = await Promise.all([readLiveSessions(liveDir, isAlive), contextLimits(), desktopRecords(desktop).then(desktopMarks)])
+    const [live, limits, marks] = await Promise.all([readLiveSessions(liveDir, isAlive, reusedPids), contextLimits(), desktopRecords(desktop).then(desktopMarks)])
     const found = []
     const files = new Map()
     const states = new Map()
@@ -238,7 +239,7 @@ export function claudeCode({
     const stat = file ? await fsp.stat(file).catch(() => null) : null
     if (!stat) return null
     const state = await (known.get(id) === file ? transcripts : olderReader(file)).read(file, stat)
-    const [live, limits, marks] = await Promise.all([readLiveSessions(liveDir, isAlive), contextLimits(), desktopRecords(desktop).then(desktopMarks)])
+    const [live, limits, marks] = await Promise.all([readLiveSessions(liveDir, isAlive, reusedPids), contextLimits(), desktopRecords(desktop).then(desktopMarks)])
     const said = await opened(file, stat, state, limits)
     if (marks.get(id)?.archived) return null
     const running = live.get(id)