pi-better-background-tasks 0.2.9 → 0.2.11

package/README.md

@@ -15,6 +15,7 @@ Use `pi-better-background-tasks` when a command should keep running while the fo
 - Start long-running commands without blocking the current turn.
 - Watch commands until success, failure, or timeout.
 - Keep task metadata and logs available across reloads.
+- Retain completed task artifacts for seven days, then remove them during rate-limited maintenance.
 - Show active work in Pi's background-work navigator.
 - Flag running tasks with no observable output or completed poll as stalled.
 - Confine local task writes to the project directory when `pi-better-sandbox` is enabled.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-better-background-tasks",
-  "version": "0.2.9",
+  "version": "0.2.11",
   "description": "Pi extension for durable background shell tasks, watchers, logs, and status inspection.",
   "license": "MIT",
   "type": "module",

package/src/goal-provider.ts

@@ -1,5 +1,5 @@
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { listMetas } from "./registry.js";
+import { listMetas, listMetasForOrigin, onMetaChanged } from "./registry.js";
 import type { BackgroundTaskMeta } from "./types.js";
 import { isTerminalStatus } from "./types.js";
 import { backgroundTaskProgressAt, observeBackgroundTaskStall } from "./stall.js";
@@ -46,7 +46,8 @@ export function registerBackgroundTasksGoalProvider(pi: ExtensionAPI): void {
     pi.events?.emit(GOAL_REGISTER_PROVIDER_EVENT, {
       id: "background-tasks",
       label: "Background Tasks",
-      getActivity: (ctx: ExtensionContext) => collectBackgroundTaskGoalActivity(listMetas(), ctx),
+      getActivity: (ctx: ExtensionContext) => collectBackgroundTaskGoalActivity(listMetasForOrigin(getGoalActivityOrigin(ctx)), ctx),
+      onActivityChanged: onMetaChanged,
     });
   };
 

package/src/maintenance.ts

@@ -0,0 +1,96 @@
+import { mkdirSync, readFileSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { baseDir, listMetas, removeMeta, writeMeta } from "./registry.js";
+import { processIdentityAlive as defaultProcessIdentityAlive } from "./process-identity.js";
+import type { BackgroundTaskCallbackOrigin, BackgroundTaskMeta } from "./types.js";
+import { isTerminalStatus } from "./types.js";
+
+export const DEFAULT_TASK_RETENTION_MS = 7 * 24 * 60 * 60 * 1000;
+const STALE_MAINTENANCE_LOCK_MS = 10 * 60 * 1000;
+
+interface MaintenanceState {
+  lastDate?: string;
+}
+
+export interface TaskMaintenanceOptions {
+  now?: number;
+  activeOrigin?: BackgroundTaskCallbackOrigin;
+  retentionMs?: number;
+  processIdentityAlive?: (pid: number | undefined, token?: string, recordedAt?: number) => boolean;
+  metas?: BackgroundTaskMeta[];
+  force?: boolean;
+}
+
+export interface TaskMaintenanceResult {
+  ran: boolean;
+  reconciled: number;
+  removed: number;
+}
+
+export function runTaskMaintenance(options: TaskMaintenanceOptions = {}): TaskMaintenanceResult {
+  const now = options.now ?? Date.now();
+  const date = new Date(now).toISOString().slice(0, 10);
+  const statePath = join(baseDir(), "maintenance-state.json");
+  const lockPath = join(baseDir(), "maintenance.lock");
+  if (!options.force && readState(statePath).lastDate === date) return { ran: false, reconciled: 0, removed: 0 };
+  if (!options.force && !acquireMaintenanceLock(lockPath, now)) return { ran: false, reconciled: 0, removed: 0 };
+
+  let reconciled = 0;
+  let removed = 0;
+  try {
+    const identityAlive = options.processIdentityAlive ?? defaultProcessIdentityAlive;
+    const metas = options.metas ?? listMetas();
+    for (const meta of metas) {
+      if (meta.status !== "running" || belongsToOrigin(meta, options.activeOrigin)) continue;
+      if (identityAlive(meta.spawnPid, meta.spawnPidStartTime, meta.startedAt)) continue;
+      if (meta.remote?.session === "tmux") continue;
+      if (meta.kind === "process" && identityAlive(meta.pid, meta.pidStartTime, meta.startedAt)) continue;
+      meta.status = "failed";
+      meta.endedAt = now;
+      meta.error = "task supervisor is no longer alive; execution result is unavailable";
+      meta.result = { reason: meta.error };
+      writeMeta(meta);
+      reconciled += 1;
+    }
+
+    const cutoff = now - (options.retentionMs ?? DEFAULT_TASK_RETENTION_MS);
+    for (const meta of metas) {
+      if (!isTerminalStatus(meta.status)) continue;
+      if ((meta.endedAt ?? meta.startedAt) >= cutoff) continue;
+      if (removeMeta(meta)) removed += 1;
+    }
+    if (!options.force) writeFileSync(statePath, JSON.stringify({ lastDate: date } satisfies MaintenanceState));
+    return { ran: true, reconciled, removed };
+  } finally {
+    if (!options.force) rmSync(lockPath, { recursive: true, force: true });
+  }
+}
+
+function readState(path: string): MaintenanceState {
+  try { return JSON.parse(readFileSync(path, "utf8")) as MaintenanceState; } catch { return {}; }
+}
+
+function acquireMaintenanceLock(path: string, now: number): boolean {
+  mkdirSync(baseDir(), { recursive: true });
+  try {
+    mkdirSync(path);
+    return true;
+  } catch {
+    try {
+      if (now - statSync(path).mtimeMs <= STALE_MAINTENANCE_LOCK_MS) return false;
+      rmSync(path, { recursive: true, force: true });
+      mkdirSync(path);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+}
+
+function belongsToOrigin(meta: BackgroundTaskMeta, active: BackgroundTaskCallbackOrigin | undefined): boolean {
+  if (!active) return false;
+  const origin = meta.callbackOrigin ?? { cwd: meta.cwd };
+  if (origin.cwd !== active.cwd) return false;
+  if (origin.sessionId || active.sessionId) return origin.sessionId === active.sessionId;
+  return true;
+}

package/src/navigator-provider.ts

@@ -10,7 +10,7 @@ import {
 import { CustomEditor } from "@earendil-works/pi-coding-agent";
 import { Key, matchesKey, truncateToWidth } from "@earendil-works/pi-tui";
 import { readLog } from "./logs.js";
-import { listMetas, onMetaChanged, readMeta, writeMeta } from "./registry.js";
+import { listMetasForOrigin, onMetaChanged, readMeta, writeMeta } from "./registry.js";
 import { stopTask } from "./runtime.js";
 import { observeBackgroundTaskStall } from "./stall.js";
 import type { BackgroundTaskCallbackOrigin, BackgroundTaskMeta, BackgroundTaskStatus } from "./types.js";
@@ -67,7 +67,9 @@ const provider: BackgroundWorkProvider = {
 };
 
 function visibleMetas(now = Date.now()): BackgroundTaskMeta[] {
-  return listMetas().filter((meta) => meta.dismissedAt === undefined && belongsToActiveNavigatorSession(meta) && !isExpiredTerminalNavigatorRow(meta, now));
+  const active = activeNavigatorOrigin;
+  if (!active) return [];
+  return listMetasForOrigin(active).filter((meta) => meta.dismissedAt === undefined && belongsToActiveNavigatorSession(meta) && !isExpiredTerminalNavigatorRow(meta, now));
 }
 
 function getNavigatorOrigin(ctx: ExtensionContext): BackgroundTaskCallbackOrigin {

package/src/process-identity.ts

@@ -0,0 +1,41 @@
+import { execFileSync } from "node:child_process";
+
+const selfStartToken = readProcessStartToken(process.pid);
+
+export function currentProcessStartToken(): string | undefined {
+  return selfStartToken;
+}
+
+export function readProcessStartToken(pid: number): string | undefined {
+  if (!Number.isInteger(pid) || pid <= 0 || process.platform === "win32") return undefined;
+  try {
+    const output = execFileSync("ps", ["-o", "lstart=", "-p", String(pid)], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+      timeout: 2_000,
+    }).trim();
+    return output || undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+export function processIdentityAlive(
+  pid: number | undefined,
+  recordedStartToken?: string,
+  recordedAt?: number,
+): boolean {
+  if (!pid || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code !== "EPERM") return false;
+  }
+  const current = readProcessStartToken(pid);
+  if (recordedStartToken && current) return recordedStartToken === current;
+  if (!recordedStartToken && current && recordedAt !== undefined) {
+    const currentStartedAt = Date.parse(current);
+    if (Number.isFinite(currentStartedAt) && currentStartedAt > recordedAt + 2_000) return false;
+  }
+  return true;
+}

package/src/registry.ts

@@ -1,12 +1,36 @@
-import { mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
+import { createHash } from "node:crypto";
+import { mkdirSync, readFileSync, readdirSync, rmSync, statSync, unlinkSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import type { BackgroundTaskMeta } from "./types.js";
+import type { BackgroundTaskCallbackOrigin, BackgroundTaskMeta } from "./types.js";
 import { isTerminalStatus } from "./types.js";
 
 let seq = 0;
 const metaCache = new Map<string, BackgroundTaskMeta>();
+// Owned snapshots are process-resident. A cheap directory signature catches
+// cross-process index changes before any cached IDs are reused.
+const indexIdsCache = new Map<string, { ids: Set<string>; signature: string }>();
+const initializedIndexes = new Set<string>();
 const metaChangedListeners = new Set<() => void>();
+const registryIo = { fullDirectoryReads: 0, indexDirectoryReads: 0, metadataFileReads: 0, indexRevisionChecks: 0 };
+
+export interface RegistryIoMetrics {
+  fullDirectoryReads: number;
+  indexDirectoryReads: number;
+  metadataFileReads: number;
+  indexRevisionChecks: number;
+}
+
+export function getRegistryIoMetrics(): RegistryIoMetrics {
+  return { ...registryIo };
+}
+
+export function resetRegistryIoMetrics(): void {
+  registryIo.fullDirectoryReads = 0;
+  registryIo.indexDirectoryReads = 0;
+  registryIo.metadataFileReads = 0;
+  registryIo.indexRevisionChecks = 0;
+}
 
 export function baseDir(): string {
   const vitestPoolId = process.env.VITEST_POOL_ID;
@@ -56,6 +80,7 @@ export function writeMeta(meta: BackgroundTaskMeta): void {
   ensureTaskDir(meta.id);
   writeFileSync(metaPathFor(meta.id), JSON.stringify(meta, null, 2));
   metaCache.set(meta.id, meta);
+  indexMeta(meta);
   for (const listener of metaChangedListeners) {
     try { listener(); } catch { /* best effort */ }
   }
@@ -68,6 +93,7 @@ export function onMetaChanged(listener: () => void): () => void {
 
 export function readMeta(id: string): BackgroundTaskMeta | undefined {
   try {
+    registryIo.metadataFileReads += 1;
     const meta = JSON.parse(readFileSync(metaPathFor(id), "utf8")) as BackgroundTaskMeta;
     metaCache.set(id, meta);
     return meta;
@@ -77,9 +103,25 @@ export function readMeta(id: string): BackgroundTaskMeta | undefined {
   }
 }
 
+export function removeMeta(meta: BackgroundTaskMeta): boolean {
+  try {
+    rmSync(taskDir(meta.id), { recursive: true, force: true });
+    metaCache.delete(meta.id);
+    removeIndexEntry(originIndexDir(originOf(meta)), meta.id);
+    removeIndexEntry(originActiveIndexDir(originOf(meta)), meta.id);
+    for (const listener of metaChangedListeners) {
+      try { listener(); } catch { /* best effort */ }
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 export function listMetas(): BackgroundTaskMeta[] {
   let ids: string[];
   try {
+    registryIo.fullDirectoryReads += 1;
     ids = readdirSync(tasksDir());
   } catch {
     return [];
@@ -94,8 +136,158 @@ export function listMetas(): BackgroundTaskMeta[] {
     .sort((a, b) => b.startedAt - a.startedAt);
 }
 
+export function listMetasForOrigin(origin: BackgroundTaskCallbackOrigin): BackgroundTaskMeta[] {
+  const directory = originIndexDir(origin);
+  ensureOriginIndex(origin, directory);
+  return readIndexIds(directory)
+    .map(readOwnedMeta)
+    .filter((meta): meta is BackgroundTaskMeta => meta !== undefined && belongsToOrigin(meta, origin))
+    .sort((a, b) => b.startedAt - a.startedAt);
+}
+
+export function listActiveMetasForOrigin(origin: BackgroundTaskCallbackOrigin): BackgroundTaskMeta[] {
+  const directory = originActiveIndexDir(origin);
+  ensureOriginActiveIndex(origin, directory);
+  return readIndexIds(directory)
+    .map(readOwnedMeta)
+    .filter((meta): meta is BackgroundTaskMeta => meta !== undefined && meta.status === "running" && belongsToOrigin(meta, origin))
+    .sort((a, b) => b.startedAt - a.startedAt);
+}
+
 function readMetaForSweep(id: string): BackgroundTaskMeta | undefined {
   const cached = metaCache.get(id);
   if (cached && isTerminalStatus(cached.status)) return cached;
   return readMeta(id);
 }
+
+function readOwnedMeta(id: string): BackgroundTaskMeta | undefined {
+  return metaCache.get(id) ?? readMeta(id);
+}
+
+function originOf(meta: BackgroundTaskMeta): BackgroundTaskCallbackOrigin {
+  return meta.callbackOrigin ?? { cwd: meta.cwd };
+}
+
+function belongsToOrigin(meta: BackgroundTaskMeta, origin: BackgroundTaskCallbackOrigin): boolean {
+  const candidate = originOf(meta);
+  if (candidate.cwd !== origin.cwd) return false;
+  if (candidate.sessionId || origin.sessionId) return candidate.sessionId === origin.sessionId;
+  return true;
+}
+
+function originIndexDir(origin: BackgroundTaskCallbackOrigin): string {
+  return join(baseDir(), "by-origin", originKey(origin));
+}
+
+function originActiveIndexDir(origin: BackgroundTaskCallbackOrigin): string {
+  return join(baseDir(), "by-origin-active", originKey(origin));
+}
+
+function originKey(origin: BackgroundTaskCallbackOrigin): string {
+  return createHash("sha256")
+    .update(origin.cwd)
+    .update("\0")
+    .update(origin.sessionId ?? "")
+    .digest("hex")
+    .slice(0, 24);
+}
+
+function indexMeta(meta: BackgroundTaskMeta): void {
+  try {
+    const directory = originIndexDir(originOf(meta));
+    writeIndexEntry(directory, meta.id);
+    const activeDirectory = originActiveIndexDir(originOf(meta));
+    if (meta.status === "running") writeIndexEntry(activeDirectory, meta.id);
+    else removeIndexEntry(activeDirectory, meta.id);
+  } catch {
+    // Indexes are accelerators; meta.json remains authoritative.
+  }
+}
+
+function ensureOriginIndex(origin: BackgroundTaskCallbackOrigin, directory: string): void {
+  if (initializedIndexes.has(directory)) return;
+  try {
+    readFileSync(join(directory, ".initialized"));
+    initializedIndexes.add(directory);
+    return;
+  } catch {
+    // Existing registries are backfilled once for each session origin.
+  }
+  indexIdsCache.delete(directory);
+  const owned = listMetas().filter((meta) => belongsToOrigin(meta, origin));
+  mkdirSync(directory, { recursive: true });
+  for (const meta of owned) writeIndexEntry(directory, meta.id);
+  writeFileSync(join(directory, ".initialized"), "1");
+  initializedIndexes.add(directory);
+}
+
+function ensureOriginActiveIndex(origin: BackgroundTaskCallbackOrigin, directory: string): void {
+  if (initializedIndexes.has(directory)) return;
+  try {
+    readFileSync(join(directory, ".initialized"));
+    initializedIndexes.add(directory);
+    return;
+  } catch {
+    // Existing registries are backfilled once for this origin's active set.
+  }
+  indexIdsCache.delete(directory);
+  const owned = listMetasForOrigin(origin).filter((meta) => meta.status === "running");
+  mkdirSync(directory, { recursive: true });
+  for (const meta of owned) writeIndexEntry(directory, meta.id);
+  writeFileSync(join(directory, ".initialized"), "1");
+  initializedIndexes.add(directory);
+}
+
+function readIndexIds(directory: string): string[] {
+  const signature = indexDirectorySignature(directory);
+  const cached = indexIdsCache.get(directory);
+  if (cached && cached.signature === signature) return [...cached.ids];
+  try {
+    registryIo.indexDirectoryReads += 1;
+    const ids = new Set(readdirSync(directory).filter((id) => id !== ".initialized"));
+    indexIdsCache.set(directory, { ids, signature: indexDirectorySignature(directory) });
+    return [...ids];
+  } catch {
+    indexIdsCache.delete(directory);
+    return [];
+  }
+}
+
+function writeIndexEntry(directory: string, id: string): void {
+  mkdirSync(directory, { recursive: true });
+  const cached = indexIdsCache.get(directory);
+  const cacheWasCurrent = cached ? cached.signature === indexDirectorySignature(directory) : false;
+  try {
+    writeFileSync(join(directory, id), "", { flag: "wx" });
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code !== "EEXIST") throw error;
+  }
+  if (cached && cacheWasCurrent) {
+    cached.ids.add(id);
+    cached.signature = indexDirectorySignature(directory);
+  } else if (cached) {
+    indexIdsCache.delete(directory);
+  }
+}
+
+function removeIndexEntry(directory: string, id: string): void {
+  const cached = indexIdsCache.get(directory);
+  const cacheWasCurrent = cached ? cached.signature === indexDirectorySignature(directory) : false;
+  try { unlinkSync(join(directory, id)); } catch { /* stale index entries are harmless */ }
+  if (cached && cacheWasCurrent) {
+    cached.ids.delete(id);
+    cached.signature = indexDirectorySignature(directory);
+  } else if (cached) {
+    indexIdsCache.delete(directory);
+  }
+}
+
+function indexDirectorySignature(directory: string): string {
+  registryIo.indexRevisionChecks += 1;
+  try {
+    const stat = statSync(directory);
+    return `${stat.dev}:${stat.ino}:${stat.mtimeMs}:${stat.ctimeMs}`;
+  } catch {
+    return "missing";
+  }
+}

package/src/runtime.ts

@@ -3,6 +3,7 @@ import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { appendLine, appendTaskOutput, appendWatchResult, retainLogTail, resolveMaxLogBytes } from "./logs.js";
 import { evaluateCondition } from "./conditions.js";
 import { processExists, runCommandOnce, spawnCommand, stopProcessGroup } from "./process.js";
+import { currentProcessStartToken, readProcessStartToken } from "./process-identity.js";
 import { DEFAULT_TMUX_BOOTSTRAP_TIMEOUT_MS, expandSshRemoteTaskPreset } from "./remote-task-preset.js";
 import type { RemoteRunner, ResolvedSshRemoteTask } from "./remote-task-preset.js";
 import { ensureTaskDir, logPathFor, nextTaskId, readMeta, sandboxProfilePathFor, writeMeta } from "./registry.js";
@@ -122,8 +123,10 @@ export function spawnTask(
     launchArgv: launchArgvOf(commandSpec, launchSpec),
     maxLogBytes: resolveMaxLogBytes(params.max_log_bytes),
     pid: spawned?.child.pid,
+    pidStartTime: spawned?.child.pid ? readProcessStartToken(spawned.child.pid) : undefined,
     pgid: spawned?.pgid,
     spawnPid: process.pid,
+    spawnPidStartTime: currentProcessStartToken(),
     ssh: remoteTask?.metadata.ssh,
     remote: remoteTask?.metadata.remote,
   };
@@ -347,6 +350,7 @@ export function startWatchTask(
     launchArgv: launchArgvOf(commandSpec, launchSpec),
     maxLogBytes: resolveMaxLogBytes(params.max_log_bytes),
     spawnPid: process.pid,
+    spawnPidStartTime: currentProcessStartToken(),
     successWhen: params.success_when,
     failureWhen: params.failure_when,
     notifyOn: "terminal",
@@ -379,6 +383,12 @@ export function resumeRunningTask(
     return meta;
   }
 
+  if (meta.spawnPid !== process.pid || meta.spawnPidStartTime !== currentProcessStartToken()) {
+    meta.spawnPid = process.pid;
+    meta.spawnPidStartTime = currentProcessStartToken();
+    writeMeta(meta);
+  }
+
   const remoteTask = resolvePersistedRemoteTask(meta, dependencies.remoteRunner);
   if (meta.kind === "command_watch") {
     scheduleWatch(pi, meta.id, 0, getActiveSession, remoteTask

package/src/shared-navigator.ts

@@ -161,7 +161,7 @@ export function isNavigatorUiAvailable(ctx: ExtensionContext | undefined): boole
 }
 
 export function navigatorFooterHint(count: number): string | null {
-  return count > 0 ? `← navigate · ${count}` : null;
+  return count > 0 ? `← work · ${count}` : null;
 }
 
 export function applyNavigatorFooter(ui: { setStatus(key: string, value: string | undefined): void }, count: number): string | null {
@@ -460,7 +460,9 @@ function buildMainListLines(
 }
 
 function shortcutsLine(focused: boolean, fg: (color: string, value: string) => string): string {
-  const keys = focused ? "↑↓ switch · Enter detail · x stop · Esc unfocus" : "← to navigate";
+  const keys = focused
+    ? "↑↓ switch · Enter detail · x stop · Esc unfocus"
+    : "← work navigator";
   return dim(keys, fg);
 }
 

package/src/tools.ts

@@ -3,8 +3,9 @@ import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-a
 import { readLog } from "./logs.js";
 import { refreshBackgroundTasksNavigator } from "./navigator-provider.js";
 import { cancelCallbackBatch } from "./shared-callback-batcher.js";
-import { listMetas, readMeta, writeMeta } from "./registry.js";
+import { listActiveMetasForOrigin, listMetas, listMetasForOrigin, readMeta, writeMeta } from "./registry.js";
 import { resumeRunningTask, spawnTask, startWatchTask, stopTask } from "./runtime.js";
+import { runTaskMaintenance } from "./maintenance.js";
 import { ForegroundSandboxBlockedError } from "./sandbox.js";
 import type { BackgroundTaskCallbackOrigin, BackgroundTaskMeta } from "./types.js";
 import { isTerminalStatus } from "./types.js";
@@ -108,7 +109,8 @@ export function registerTools(pi: ExtensionAPI): void {
 
   pi.on("session_start", async (_event, ctx) => {
     activeSession = getCallbackOrigin(ctx);
-    for (const meta of listMetas()) resumeRunningTask(pi, meta, getActiveSession);
+    for (const meta of listActiveMetasForOrigin(activeSession)) resumeRunningTask(pi, meta, getActiveSession);
+    runTaskMaintenance({ activeOrigin: activeSession });
   });
   pi.on("session_before_switch", () => {
     activeSession = undefined;
@@ -499,7 +501,7 @@ function formatClear(statuses: string[] | undefined, active: BackgroundTaskCallb
   const wanted = statuses && statuses.length > 0 ? new Set(statuses) : undefined;
   const now = Date.now();
   let cleared = 0;
-  for (const meta of listMetas()) {
+  for (const meta of listMetasForOrigin(active)) {
     if (meta.dismissedAt !== undefined) continue;
     if (!isTerminalStatus(meta.status)) continue;
     if (wanted && !wanted.has(meta.status)) continue;

package/src/types.ts

@@ -103,8 +103,12 @@ export interface BackgroundTaskMeta {
   logDiscardedBytes?: number;
   logRetentionEvents?: number;
   pid?: number;
+  /** Opaque process-start token used to reject recycled child PIDs. */
+  pidStartTime?: string;
   pgid?: number;
   spawnPid: number;
+  /** Opaque process-start token used to reject recycled supervisor PIDs. */
+  spawnPidStartTime?: string;
   successWhen?: Condition;
   failureWhen?: Condition;
   notifyOn?: "terminal";