@yeaft/webchat-agent 0.1.1104 → 0.1.1107

package/yeaft/sessions/session-crud.js

@@ -12,16 +12,18 @@
  * Plus the D1 bootstrap helper:
  *   ensureDefaultSessionIfEmpty(yeaftDir, {libDir}) — if NO session exists on
  *   disk, seed `session_default` with roster = every VP in the library, and
- *   defaultVpId = alphabetically first vpId. No-op when ≥1 session present.
+ *   defaultVpId = `omni` when present, otherwise the alphabetically first vpId.
+ *   No-op when ≥1 session present.
  *
  * Hard constraints (PM):
  *   (a) We don't touch 334o storage primitives (storage/index.js) — we call
  *       group-store.openSession / saveMeta which already go through openLog.
  *   (b) We don't touch VP entity (vp-store.js / vp-loader.js) — only read
  *       via scanVpLibrary to know which VPs exist at seed time.
- *   (c) When `addMember` is called with an empty roster and no defaultVpId
- *       resolvable, callers surface `no_default_vp` via `createSessionFromSpec`;
- *       on `removeMember` we permit the empty state (UI nudges the user).
+ *   (c) `createSessionFromSpec` seeds omitted/empty rosters with the default
+ *       generalist VP when the library has one; truly empty VP libraries can
+ *       still create empty sessions and surface `no_default_vp` on first send.
+ *       On `removeMember` we permit the empty state (UI nudges the user).
  *
  * Error shape — every throw is a `SessionCrudError` with a stable `.code`:
  *   'not_found'        — group id has no dir / meta
@@ -98,6 +100,7 @@ export class SessionCrudError extends Error {
 }
 
 const GROUP_WORKDIR_REGISTRY = 'group-workdirs.json';
+const DEFAULT_VP_ID = 'omni';
 
 export function sessionsRoot(yeaftDir) {
   return join(yeaftDir, 'sessions');
@@ -260,11 +263,24 @@ export function makeSessionId(name) {
   return nextSessionId(slug);
 }
 
+function preferDefaultVp(vpIds) {
+  if (!Array.isArray(vpIds) || vpIds.length === 0) return null;
+  return vpIds.includes(DEFAULT_VP_ID) ? DEFAULT_VP_ID : vpIds[0];
+}
+
+function scanSortedVpIds(libDir) {
+  const vpIds = scanVpLibrary({ dir: libDir })
+    .map(v => v && v.id)
+    .filter(v => typeof v === 'string' && v.length > 0);
+  vpIds.sort((a, b) => a.localeCompare(b));
+  return vpIds;
+}
+
 /**
  * (B) D1 seed — called at boot (or when multi-VP is first enabled). Idempotent:
  * returns `{seeded:false}` if any session already exists on disk (including
  * `session_default`). When empty, seeds with roster = full VP library, sorted
- * alphabetically; defaultVpId = roster[0].
+ * alphabetically; defaultVpId = `omni` when present, otherwise roster[0].
  *
  * When the VP library is also empty, we still seed an empty-roster session so
  * the UI has somewhere to land — but defaultVpId is null and downstream
@@ -278,14 +294,12 @@ export function ensureDefaultSessionIfEmpty(yeaftDir, options = {}) {
     return { seeded: false, sessionId: existing[0].id };
   }
 
-  // Sort VP ids alphabetically (stable for tests / deterministic UI).
-  // NB: vp-store returns records with `.id` (not `.vpId`) — keep this in sync.
-  const vps = scanVpLibrary({ dir: libDir })
-    .map(v => v && v.id)
-    .filter(v => typeof v === 'string' && v.length > 0);
-  vps.sort((a, b) => a.localeCompare(b));
+  // Sort VP ids alphabetically (stable for tests / deterministic UI), but
+  // prefer the generalist Omni VP as the default when present so first-run
+  // sessions land on a useful assistant instead of an arbitrary first id.
+  const vps = scanSortedVpIds(libDir);
 
-  const defaultVpId = vps[0] || null;
+  const defaultVpId = preferDefaultVp(vps);
   const { group, created } = seedDefaultSession(yeaftDir, {
     name: options.name || 'Default',
     roster: vps,
@@ -301,21 +315,27 @@ export function ensureDefaultSessionIfEmpty(yeaftDir, options = {}) {
 }
 
 /**
- * (A.1) Create group from a wizard spec. `spec.roster` is authoritative —
- * we do NOT auto-expand to the full VP library here. That's D1's job only.
+ * (A.1) Create session from a wizard spec. `spec.roster` is authoritative
+ * when non-empty. If the caller omits a roster, seed the session with the
+ * default generalist VP (`omni`) when it exists so a new Session is usable
+ * immediately instead of opening with an empty roster.
  *
  * @param {string} yeaftDir
  * @param {{name:string, roster?:string[], defaultVpId?:string|null, workDir?:string}} spec
  * @returns {{id:string, name:string, roster:string[], defaultVpId:string|null, workDir?:string}}
  */
 export function createSessionFromSpec(yeaftDir, spec, options = {}) {
-  const normalizedWorkDir = normalizeWorkDir(spec && spec.workDir);
+  const input = spec || {};
+  const normalizedWorkDir = normalizeWorkDir(input.workDir);
   const groupYeaftDir = normalizedWorkDir ? yeaftDirForWorkDir(normalizedWorkDir) : yeaftDir;
   const memoryRoot = options.memoryRoot || (groupYeaftDir ? join(groupYeaftDir, 'memory') : DEFAULT_MEMORY_ROOT);
-  const name = String(spec && spec.name || '').trim();
+  const libDir = options.libDir || DEFAULT_VP_LIB_DIR;
+  const name = String(input.name || '').trim();
   if (!name) throw new SessionCrudError('invalid_name', null, 'group name required');
 
-  const roster = Array.isArray(spec.roster) ? spec.roster.slice() : [];
+  const callerRoster = Array.isArray(input.roster) ? input.roster.slice() : [];
+  const fallbackVpId = callerRoster.length > 0 ? null : preferDefaultVp(scanSortedVpIds(libDir));
+  const roster = callerRoster.length > 0 ? callerRoster : (fallbackVpId ? [fallbackVpId] : []);
   // Validate every member up-front so we fail before touching fs.
   for (const vpId of roster) {
     if (isReservedVpId(vpId)) {
@@ -325,10 +345,9 @@ export function createSessionFromSpec(yeaftDir, spec, options = {}) {
     if (!v.ok) throw new SessionCrudError(v.reason, null, `invalid vpId: ${vpId}`);
   }
 
-  // defaultVpId resolution: explicit > roster[0] > null. Null is allowed at
-  // create time (empty roster) — the wizard modal warns the user downstream
-  // (task-334m spec: `no_default_vp` surfaced on first send, not on create).
-  let defaultVpId = spec.defaultVpId || null;
+  // defaultVpId resolution: explicit > roster[0] > null. Null is only
+  // possible when both caller roster and VP library are empty.
+  let defaultVpId = input.defaultVpId || null;
   if (defaultVpId && !roster.includes(defaultVpId)) {
     throw new SessionCrudError('default_not_in_roster', null, `${defaultVpId} not in roster`);
   }
@@ -354,8 +373,8 @@ export function createSessionFromSpec(yeaftDir, spec, options = {}) {
   // turn.
   try {
     ensureSessionConfigFile(yeaftDir, id);
-    if (spec && spec.config && typeof spec.config === 'object') {
-      saveSessionConfig(yeaftDir, id, spec.config);
+    if (input.config && typeof input.config === 'object') {
+      saveSessionConfig(yeaftDir, id, input.config);
     }
   } catch (err) {
     console.warn(`[session-crud] failed to seed config.json for ${id}:`, err?.message || err);

package/yeaft/systemd-scope.js

@@ -0,0 +1,88 @@
+/**
+ * systemd-scope.js — run child processes outside the agent service cgroup.
+ *
+ * When yeaft-agent runs as a systemd user service, shell tasks inherit the
+ * yeaft-agent.service cgroup by default. Long-lived commands then show up as
+ * "left-over process" entries every time the agent service restarts. Wrapping
+ * shell commands in a transient user scope keeps those user workloads alive
+ * without polluting the agent service lifecycle.
+ */
+
+import { existsSync } from 'fs';
+import { delimiter, isAbsolute, join } from 'path';
+
+const DEFAULT_SCOPE_PREFIX = 'yeaft-shell';
+const UNIT_MAX_LENGTH = 180;
+
+function hasPathSeparator(command) {
+  return command.includes('/') || command.includes('\\');
+}
+
+export function findExecutableOnPath(command, env = process.env) {
+  if (!command || typeof command !== 'string') return null;
+  if (hasPathSeparator(command)) return existsSync(command) ? command : null;
+
+  const pathValue = env.PATH || '';
+  for (const dir of pathValue.split(delimiter)) {
+    if (!dir) continue;
+    const candidate = isAbsolute(dir) ? join(dir, command) : join(process.cwd(), dir, command);
+    if (existsSync(candidate)) return candidate;
+  }
+  return null;
+}
+
+export function shouldUseSystemdUserScope({ runtimePlatform, env = process.env, systemdRunPath = null } = {}) {
+  if (!runtimePlatform?.isLinux) return false;
+  if (env.YEAFT_DISABLE_SYSTEMD_SCOPE === '1') return false;
+
+  // INVOCATION_ID is set for systemd services and transient scopes. XDG_RUNTIME_DIR
+  // is required for `systemd-run --user` to talk to the user manager.
+  if (!env.INVOCATION_ID || !env.XDG_RUNTIME_DIR) return false;
+
+  const resolvedSystemdRun = systemdRunPath || findExecutableOnPath('systemd-run', env);
+  return !!resolvedSystemdRun;
+}
+
+export function sanitizeSystemdUnitPart(value) {
+  const raw = String(value || '').trim() || `${Date.now()}-${process.pid}`;
+  return raw
+    .replace(/[^A-Za-z0-9_.-]+/g, '-')
+    .replace(/^-+|-+$/g, '')
+    .slice(0, UNIT_MAX_LENGTH) || `${Date.now()}-${process.pid}`;
+}
+
+export function buildSystemdScopeName(scopeId, prefix = DEFAULT_SCOPE_PREFIX) {
+  const safePrefix = sanitizeSystemdUnitPart(prefix).slice(0, 48);
+  const safeId = sanitizeSystemdUnitPart(scopeId);
+  const base = `${safePrefix}-${safeId}`.slice(0, UNIT_MAX_LENGTH);
+  return base.endsWith('.scope') ? base : `${base}.scope`;
+}
+
+export function wrapInvocationInSystemdUserScope(invocation, {
+  runtimePlatform,
+  env = process.env,
+  scopeId = null,
+  scopePrefix = DEFAULT_SCOPE_PREFIX,
+  systemdRunPath = null,
+} = {}) {
+  if (!shouldUseSystemdUserScope({ runtimePlatform, env, systemdRunPath })) {
+    return { ...invocation, systemdScope: null };
+  }
+
+  const scopeName = buildSystemdScopeName(scopeId, scopePrefix);
+  return {
+    command: systemdRunPath || findExecutableOnPath('systemd-run', env) || 'systemd-run',
+    args: [
+      '--user',
+      '--scope',
+      '--quiet',
+      '--collect',
+      `--unit=${scopeName}`,
+      invocation.command,
+      ...(invocation.args || []),
+    ],
+    family: invocation.family,
+    systemdScope: scopeName,
+    wrappedCommand: invocation.command,
+  };
+}

package/yeaft/tasks/manager.js

@@ -11,6 +11,12 @@ import { startShellProcess } from './shell-runner.js';
 import { getRuntimePlatformInfo } from '../runtime-platform.js';
 
 const LOG_PREVIEW_BYTES = 4096;
+const SUB_AGENT_LOG_PREVIEW_BYTES = 1024 * 1024;
+const DEFAULT_CANCEL_ESCALATION_MS = 2000;
+
+function logPreviewBytesFor(task) {
+  return task?.kind === 'sub_agent' ? SUB_AGENT_LOG_PREVIEW_BYTES : LOG_PREVIEW_BYTES;
+}
 
 function nowIso() {
   return new Date().toISOString();
@@ -40,14 +46,23 @@ function publicSnapshot(task) {
   };
 }
 
+function taskCommand(task) {
+  const command = task?.runtime?.command;
+  return typeof command === 'string' && command.trim() ? command.trim() : '';
+}
+
 export class TaskManager {
-  constructor({ yeaftDir, onEvent = null, runtimePlatform = null } = {}) {
+  constructor({ yeaftDir, onEvent = null, runtimePlatform = null, cancelEscalationMs = DEFAULT_CANCEL_ESCALATION_MS } = {}) {
     if (!yeaftDir) throw new Error('TaskManager requires yeaftDir');
     this.store = new TaskStore({ yeaftDir });
     this.onEvent = typeof onEvent === 'function' ? onEvent : null;
     this.runtimePlatform = runtimePlatform || getRuntimePlatformInfo();
+    this.cancelEscalationMs = Number.isFinite(cancelEscalationMs)
+      ? Math.max(0, Math.floor(cancelEscalationMs))
+      : DEFAULT_CANCEL_ESCALATION_MS;
     this.active = new Map();
     this.processes = new Map();
+    this.cancelEscalationTimers = new Map();
     this.#loadPersistedRunningTasks();
   }
 
@@ -134,6 +149,7 @@ export class TaskManager {
         command,
         cwd,
         pid: null,
+        systemdScope: null,
         platform: (runtimePlatform || this.runtimePlatform)?.platform || process.platform,
       },
       log: {
@@ -155,6 +171,7 @@ export class TaskManager {
       command,
       cwd,
       runtimePlatform: runtime,
+      scopeId: task.id,
       onOutput: (stream, text) => {
         const prefix = stream === 'stderr' ? '[stderr] ' : '';
         this.store.appendLog(task.sessionId, task.id, prefix ? text.split(/(\n)/).map(part => part === '\n' ? part : (part ? `${prefix}${part}` : part)).join('') : text);
@@ -176,6 +193,7 @@ export class TaskManager {
     });
 
     task.runtime.pid = runner.pid;
+    task.runtime.systemdScope = runner.systemdScope || null;
     this.processes.set(this.#key(task.sessionId, task.id), runner);
     this.store.writeTask(task);
     this.#emit('updated', task);
@@ -186,9 +204,15 @@ export class TaskManager {
     const key = this.#key(sessionId, taskId);
     const task = this.active.get(key) || this.store.readTask(sessionId, taskId);
     if (!task || isTerminalTaskStatus(task.status)) return publicSnapshot(task);
+    const escalationTimer = this.cancelEscalationTimers.get(key);
+    if (escalationTimer) {
+      clearTimeout(escalationTimer);
+      this.cancelEscalationTimers.delete(key);
+    }
     const logPath = task.log?.path || this.store.logPath(sessionId, taskId);
-    const tail = this.store.readLogFile(logPath, { tail: true, maxBytes: LOG_PREVIEW_BYTES });
-    task.status = status || TASK_STATUS.FAILED;
+    const tail = this.store.readLogFile(logPath, { tail: true, maxBytes: logPreviewBytesFor(task) });
+    const cancelRequested = !!task.runtime?.cancelRequestedAt;
+    task.status = cancelRequested ? TASK_STATUS.CANCELLED : (status || TASK_STATUS.FAILED);
     task.updatedAt = nowIso();
     task.endedAt = nowIso();
     task.log = { ...(task.log || {}), path: tail.path, bytes: tail.bytes, preview: tail.text };
@@ -207,19 +231,61 @@ export class TaskManager {
     if (!task) return { ok: false, error: `Unknown task: ${taskId}` };
     if (isTerminalTaskStatus(task.status)) return { ok: true, task: publicSnapshot(task) };
     const runner = this.processes.get(key);
-    const killed = runner ? runner.kill('SIGTERM') : false;
-    if (!killed) {
+    if (!runner) {
       return {
         ok: false,
-        error: 'Unable to cancel task: no live process handle or process-tree kill failed.',
+        error: 'Unable to cancel task: no live process handle.',
         task: publicSnapshot(task),
       };
     }
-    const completed = this.#completeTask(sessionId, taskId, {
-      status: TASK_STATUS.CANCELLED,
-      signal: 'SIGTERM',
-    });
-    return { ok: true, task: completed };
+
+    if (!task.runtime?.cancelRequestedAt) {
+      const signalled = runner.kill('SIGTERM');
+      if (!signalled) {
+        return {
+          ok: false,
+          error: 'Unable to cancel task: process-tree signal failed.',
+          task: publicSnapshot(task),
+        };
+      }
+      const cancelRequestedAt = nowIso();
+      task.runtime = {
+        ...(task.runtime || {}),
+        cancelRequestedAt,
+        cancelSignal: 'SIGTERM',
+        cancelEscalationMs: this.cancelEscalationMs,
+      };
+      task.updatedAt = cancelRequestedAt;
+      this.store.writeTask(task);
+      this.active.set(key, task);
+      this.store.appendEvent(sessionId, { event: 'cancel_requested', taskId, signal: 'SIGTERM' });
+      this.#emit('updated', task, { cancelRequested: true });
+
+      if (this.cancelEscalationMs >= 0 && !this.cancelEscalationTimers.has(key)) {
+        const timer = setTimeout(() => {
+          this.cancelEscalationTimers.delete(key);
+          const current = this.active.get(key) || this.store.readTask(sessionId, taskId);
+          if (!current || isTerminalTaskStatus(current.status)) return;
+          const liveRunner = this.processes.get(key);
+          const escalated = liveRunner ? liveRunner.kill('SIGKILL') : false;
+          current.runtime = {
+            ...(current.runtime || {}),
+            cancelEscalatedAt: nowIso(),
+            cancelEscalatedSignal: 'SIGKILL',
+            cancelEscalationFailed: !escalated,
+          };
+          current.updatedAt = current.runtime.cancelEscalatedAt;
+          this.store.writeTask(current);
+          this.active.set(key, current);
+          this.store.appendEvent(sessionId, { event: 'cancel_escalated', taskId, signal: 'SIGKILL', ok: escalated });
+          this.#emit('updated', current, { cancelEscalated: true, cancelEscalationOk: escalated });
+        }, this.cancelEscalationMs);
+        if (typeof timer.unref === 'function') timer.unref();
+        this.cancelEscalationTimers.set(key, timer);
+      }
+    }
+
+    return { ok: true, task: publicSnapshot(task), pending: true };
   }
 
   listActiveTasks(sessionId = null) {
@@ -254,7 +320,7 @@ export class TaskManager {
     const task = this.active.get(key) || this.store.readTask(sessionId, taskId);
     if (!task) return null;
     const logPath = task.log?.path || this.store.logPath(sessionId, taskId);
-    const tail = this.store.readLogFile(logPath, { tail: true, maxBytes: LOG_PREVIEW_BYTES });
+    const tail = this.store.readLogFile(logPath, { tail: true, maxBytes: logPreviewBytesFor(task) });
     task.log = { ...(task.log || {}), path: tail.path, bytes: tail.bytes, preview: tail.text };
     task.updatedAt = nowIso();
     this.store.writeTask(task);
@@ -269,7 +335,9 @@ export class TaskManager {
     const lines = ['<active_tasks>'];
     for (const task of tasks) {
       const preview = (task.log?.preview || '').trim().split('\n').slice(-3).join(' | ');
-      lines.push(`- ${task.id} | ${task.kind} | ${task.status} | owner=${task.ownerVpId || 'unknown'} | title=${JSON.stringify(task.title)} | log=${task.log?.path || ''}${preview ? ` | tail=${JSON.stringify(preview)}` : ''}`);
+      const command = taskCommand(task);
+      const cancelRequestedAt = typeof task.runtime?.cancelRequestedAt === 'string' ? task.runtime.cancelRequestedAt : '';
+      lines.push(`- ${task.id} | ${task.kind} | ${task.status} | owner=${task.ownerVpId || 'unknown'} | title=${JSON.stringify(task.title)}${command ? ` | command=${JSON.stringify(command)}` : ''}${cancelRequestedAt ? ` | cancelRequestedAt=${JSON.stringify(cancelRequestedAt)}` : ''} | log=${task.log?.path || ''}${preview ? ` | tail=${JSON.stringify(preview)}` : ''}`);
     }
     lines.push('</active_tasks>');
     return lines.join('\n');

package/yeaft/tasks/shell-runner.js

@@ -4,6 +4,7 @@
 
 import { spawn, spawnSync } from 'child_process';
 import { buildShellInvocation, getRuntimePlatformInfo } from '../runtime-platform.js';
+import { wrapInvocationInSystemdUserScope } from '../systemd-scope.js';
 
 export function buildWindowsTaskkillArgs(pid) {
   return ['/pid', String(pid), '/t', '/f'];
@@ -33,12 +34,18 @@ export function killShellProcessTree(pid, runtimePlatform, signal = 'SIGTERM') {
   }
 }
 
-export function startShellProcess({ command, cwd, runtimePlatform, onOutput, onExit, onError }) {
+export function startShellProcess({ command, cwd, runtimePlatform, scopeId = null, onOutput, onExit, onError }) {
   const platform = runtimePlatform || getRuntimePlatformInfo();
-  const invocation = buildShellInvocation(command, { runtimePlatform: platform });
+  const env = { ...process.env, TERM: 'dumb', FORCE_COLOR: '0' };
+  const baseInvocation = buildShellInvocation(command, { runtimePlatform: platform });
+  const invocation = wrapInvocationInSystemdUserScope(baseInvocation, {
+    runtimePlatform: platform,
+    env,
+    scopeId,
+  });
   const proc = spawn(invocation.command, invocation.args, {
     cwd,
-    env: { ...process.env, TERM: 'dumb', FORCE_COLOR: '0' },
+    env,
     stdio: ['ignore', 'pipe', 'pipe'],
     detached: !platform.isWindows,
     windowsHide: true,
@@ -57,6 +64,7 @@ export function startShellProcess({ command, cwd, runtimePlatform, onOutput, onE
 
   return {
     pid: proc.pid || null,
+    systemdScope: invocation.systemdScope || null,
     kill(signal = 'SIGTERM') {
       return killShellProcessTree(proc.pid, platform, signal);
     },

package/yeaft/tools/bash.js

@@ -13,6 +13,7 @@ import { spawn } from 'child_process';
 import { existsSync } from 'fs';
 import { resolve } from 'path';
 import { buildShellInvocation, getRuntimePlatformInfo } from '../runtime-platform.js';
+import { wrapInvocationInSystemdUserScope } from '../systemd-scope.js';
 
 export { buildShellInvocation };
 
@@ -32,10 +33,16 @@ const MAX_TIMEOUT_MS = 600_000;
 function runCommand(command, { cwd, timeout, signal, runtimePlatform }) {
   return new Promise((resolve) => {
     const platform = runtimePlatform || getRuntimePlatformInfo();
-    const invocation = buildShellInvocation(command, { runtimePlatform: platform });
+    const env = { ...process.env, TERM: 'dumb', FORCE_COLOR: '0' };
+    const baseInvocation = buildShellInvocation(command, { runtimePlatform: platform });
+    const invocation = wrapInvocationInSystemdUserScope(baseInvocation, {
+      runtimePlatform: platform,
+      env,
+      scopeId: `foreground-${Date.now()}-${process.pid}`,
+    });
     const proc = spawn(invocation.command, invocation.args, {
       cwd,
-      env: { ...process.env, TERM: 'dumb', FORCE_COLOR: '0' },
+      env,
       stdio: ['ignore', 'pipe', 'pipe'],
       detached: !platform.isWindows,
     });

package/yeaft/vp-status-broker.js

@@ -17,6 +17,11 @@ export const VALID_STATES = new Set([
 ]);
 
 const RUNNING_STATES = new Set(['typing', 'thinking', 'streaming', 'tool']);
+
+export function isVpStatusRunning(state) {
+  return RUNNING_STATES.has(state || 'idle');
+}
+
 const STATE_PRIORITY = ['tool', 'streaming', 'thinking', 'typing', 'error', 'idle'];
 const MAX_RETAINED_THREADS_PER_VP = 20;
 const COMPLETED_TTL_MS = 30 * 60 * 1000;
@@ -52,7 +57,7 @@ export function createVpStatusBroker({ send, now = Date.now } = {}) {
       }
     }
 
-    const runningThreadCount = rows.filter(r => RUNNING_STATES.has(r.state)).length;
+    const runningThreadCount = rows.filter(r => isVpStatusRunning(r.state)).length;
     const latest = rows[0] || null;
     return {
       sessionId: sessionId || null,
@@ -83,14 +88,14 @@ export function createVpStatusBroker({ send, now = Date.now } = {}) {
     }
     const cutoff = now() - COMPLETED_TTL_MS;
     for (const [key, row] of rows) {
-      if (RUNNING_STATES.has(row.state)) continue;
+      if (isVpStatusRunning(row.state)) continue;
       if ((row.updatedAt || row.since || 0) < cutoff) threads.delete(key);
     }
     const remaining = rows
       .filter(([key]) => threads.has(key))
       .sort((a, b) => (b[1].updatedAt || b[1].since || 0) - (a[1].updatedAt || a[1].since || 0));
     for (const [key, row] of remaining.slice(MAX_RETAINED_THREADS_PER_VP)) {
-      if (!RUNNING_STATES.has(row.state)) threads.delete(key);
+      if (!isVpStatusRunning(row.state)) threads.delete(key);
     }
   }