@the-open-engine/zeroshot 6.30.1 → 6.31.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@the-open-engine/zeroshot",
-  "version": "6.30.1",
+  "version": "6.31.0",
   "description": "Multi-agent orchestration engine for Claude, Codex, and Gemini",
   "main": "src/orchestrator.js",
   "bin": {
@@ -53,7 +53,7 @@
     "build:target": "tsc --project tsconfig.target.build.json",
     "build:cluster": "npm run protocol:generate && tsc --project tsconfig.cluster.cjs.json && tsc --project tsconfig.cluster.esm.json && tsc --project tsconfig.hosted-target.cjs.json && tsc --project tsconfig.hosted-target.esm.json && tsc --project tsconfig.hosted-session.cjs.json && tsc --project tsconfig.hosted-session.esm.json && node scripts/build-cluster.js",
     "test:agent-cli-provider": "node --test tests/agent-cli-provider/*.test.js",
-    "test:omp": "npm run build:agent-cli-provider && node --test tests/agent-cli-provider/omp-*.test.js && node tests/run-tests.js tests/omp-rpc-watcher.test.js tests/omp-isolation-capability.test.js tests/omp-docker-auth.test.js tests/omp-docker-fresh-only.test.js",
+    "test:omp": "npm run build:agent-cli-provider && node --test tests/agent-cli-provider/omp-*.test.js && node tests/run-tests.js 'tests/omp-rpc-watcher*.test.js' tests/omp-isolation-capability.test.js tests/omp-docker-auth.test.js tests/omp-docker-fresh-only.test.js",
     "test:providers:live": "npm run build:agent-cli-provider && node scripts/live-provider-smoke.js",
     "check:agent-cli-provider": "npm run check:agent-cli-provider:ci",
     "check:agent-cli-provider:ci": "npm run typecheck:agent-cli-provider && npm run lint:agent-cli-provider && npm run build:agent-cli-provider && npm run test:agent-cli-provider",
@@ -134,6 +134,14 @@
   "engines": {
     "node": ">=22.0.0"
   },
+  "ompSdkHostContainment": {
+    "platforms": [
+      "linux:arm64",
+      "linux:x64"
+    ],
+    "supervisor": "scripts/omp/host-supervisor.ts",
+    "protocolVersion": 1
+  },
   "publishConfig": {
     "access": "public",
     "registry": "https://registry.npmjs.org/"
@@ -178,12 +186,15 @@
     "docs/openengine-cluster-protocol/v1/legacy-worker.md",
     "README.md",
     "LICENSE",
-    "CHANGELOG.md"
+    "CHANGELOG.md",
+    "npm-shrinkwrap.json"
   ],
   "dependencies": {
+    "@oh-my-pi/pi-coding-agent": "17.2.1",
     "ajv": "^8.18.0",
     "ansi-to-html": "^0.7.2",
     "better-sqlite3": "^12.6.2",
+    "bun": "1.3.14",
     "chalk": "^4.1.2",
     "commander": "^14.0.2",
     "node-pty": "^1.1.0",
@@ -228,6 +239,8 @@
     "cosmiconfig": {
       "js-yaml": "4.2.0"
     },
+    "adm-zip": "0.6.0",
+    "sharp": "0.35.3",
     "xml2js": "^0.5.0",
     "diff": ">=8.0.3",
     "tar": ">=7.5.8",

package/scripts/omp/bun-ffi.d.ts

@@ -0,0 +1,28 @@
+declare module 'bun:ffi' {
+  type FfiArgument = number | bigint | ArrayBufferView;
+  type FfiReturn<Definition> = Definition extends { readonly returns: 'ptr' }
+    ? number
+    : Definition extends { readonly returns: 'i64' }
+      ? bigint
+      : number;
+  type FfiSymbols<Definitions extends Readonly<Record<string, unknown>>> = {
+    readonly [Name in keyof Definitions]: (
+      ...arguments_: FfiArgument[]
+    ) => FfiReturn<Definitions[Name]>;
+  };
+
+  export function dlopen<Definitions extends Readonly<Record<string, unknown>>>(
+    library: string,
+    definitions: Definitions
+  ): {
+    readonly symbols: FfiSymbols<Definitions>;
+    close(): void;
+  };
+
+  export function ptr(value: ArrayBufferView): number;
+  export function toArrayBuffer(
+    pointer: number,
+    byteOffset?: number,
+    byteLength?: number
+  ): ArrayBuffer;
+}

package/scripts/omp/host-supervisor-cleanup.ts

@@ -0,0 +1,100 @@
+import {
+  discoverOwnedProcesses,
+  ownershipEmpty,
+  reapExitedOwned,
+  signalOwned,
+  signalTracked,
+} from './host-supervisor-tracker';
+import { promiseGate } from './promise-gate';
+
+const DISCOVERY_INTERVAL_MS = 5;
+const SIGTERM = 15;
+const SIGKILL = 9;
+
+export interface SemanticOutcome {
+  readonly exitCode: number | null;
+  readonly signal: NodeJS.Signals | null;
+}
+
+function delay(milliseconds: number): Promise<void> {
+  const gate = promiseGate<void>();
+  setTimeout(() => gate.resolve(), milliseconds);
+  return gate.promise;
+}
+
+export async function awaitOutcome(
+  outcome: Promise<SemanticOutcome>,
+  deadline: number
+): Promise<SemanticOutcome | undefined> {
+  const remaining = deadline - Date.now();
+  if (remaining <= 0) return undefined;
+  const timeoutGate = promiseGate<undefined>();
+  const timer = setTimeout(() => timeoutGate.resolve(undefined), remaining);
+  try {
+    return await Promise.race([outcome, timeoutGate.promise]);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+export async function cleanupOwned(
+  rootPid: number,
+  outcomePromise: Promise<SemanticOutcome>,
+  graceMs: number,
+  reapTimeoutMs: number
+): Promise<SemanticOutcome> {
+  signalOwned(SIGTERM);
+  const gracefulDeadline = Date.now() + graceMs;
+  let outcome = await awaitOutcome(outcomePromise, gracefulDeadline);
+  while (outcome === undefined && Date.now() < gracefulDeadline) {
+    discoverOwnedProcesses();
+    reapExitedOwned(rootPid);
+    await delay(DISCOVERY_INTERVAL_MS);
+    outcome = await awaitOutcome(
+      outcomePromise,
+      Math.min(gracefulDeadline, Date.now() + DISCOVERY_INTERVAL_MS)
+    );
+  }
+
+  signalOwned(SIGKILL);
+  const reapDeadline = Date.now() + reapTimeoutMs;
+  let cleanupDeadlineExceeded = false;
+  while (outcome === undefined) {
+    discoverOwnedProcesses();
+    signalOwned(SIGKILL);
+    outcome = await awaitOutcome(outcomePromise, Date.now() + DISCOVERY_INTERVAL_MS);
+    if (Date.now() >= reapDeadline) cleanupDeadlineExceeded = true;
+  }
+  for (;;) {
+    discoverOwnedProcesses();
+    signalOwned(SIGKILL);
+    if (ownershipEmpty()) {
+      if (cleanupDeadlineExceeded) {
+        throw new Error('descendant cleanup exceeded its attestation deadline');
+      }
+      return outcome;
+    }
+    if (Date.now() >= reapDeadline) cleanupDeadlineExceeded = true;
+    await delay(DISCOVERY_INTERVAL_MS);
+  }
+}
+export async function holdOwnershipUntilEmpty(): Promise<void> {
+  for (;;) {
+    try {
+      discoverOwnedProcesses();
+    } catch {
+      // Capacity/relationship transitions cannot suppress signals to known identities.
+    }
+    try {
+      signalTracked(SIGKILL);
+    } catch {
+      // Pidfd signaling is retried while ownership is retained.
+    }
+    try {
+      if (ownershipEmpty()) return;
+    } catch {
+      // Kernel ownership is retried until ECHILD is authoritative.
+    }
+    await delay(DISCOVERY_INTERVAL_MS);
+  }
+}

package/scripts/omp/host-supervisor-launch.ts

@@ -0,0 +1,38 @@
+import { spawn, type ChildProcess } from 'node:child_process';
+
+import type { SemanticOutcome } from './host-supervisor-cleanup';
+import { installSupervisorProtection } from './host-supervisor-native';
+import { promiseGate } from './promise-gate';
+
+export function childOutcome(child: ChildProcess): Promise<SemanticOutcome> {
+  const gate = promiseGate<SemanticOutcome>();
+  child.once('error', (error) => gate.reject(error));
+  child.once('close', (exitCode, signal) => gate.resolve({ exitCode, signal }));
+  return gate.promise;
+}
+
+export async function launchProtectedSidecar(): Promise<void> {
+  const supervisorPid = Number(process.argv[3]);
+  const sidecarPath = process.argv[4];
+  const requestPath = process.argv[5];
+  if (
+    !Number.isSafeInteger(supervisorPid) ||
+    supervisorPid <= 1 ||
+    sidecarPath === undefined ||
+    requestPath === undefined
+  ) {
+    process.exitCode = 64;
+    return;
+  }
+  installSupervisorProtection(supervisorPid);
+  const child = spawn(process.execPath, [sidecarPath, requestPath], {
+    cwd: process.cwd(),
+    detached: false,
+    env: process.env,
+    shell: false,
+    stdio: ['ignore', 'inherit', 'inherit', 3],
+    windowsHide: true,
+  });
+  const outcome = await childOutcome(child);
+  process.exitCode = outcome.exitCode ?? 128;
+}

package/scripts/omp/host-supervisor-native.ts

@@ -0,0 +1,181 @@
+/// <reference path="./bun-ffi.d.ts" />
+
+import { readFileSync, readdirSync } from 'node:fs';
+import { dlopen, ptr, toArrayBuffer } from 'bun:ffi';
+
+export const PR_SET_DUMPABLE = 4;
+export const PR_SET_SECCOMP = 22;
+export const PR_SET_CHILD_SUBREAPER = 36;
+export const PR_GET_CHILD_SUBREAPER = 37;
+export const PR_SET_NO_NEW_PRIVS = 38;
+export const SECCOMP_MODE_FILTER = 2;
+export const SECCOMP_RET_ALLOW = 0x7fff0000;
+export const SECCOMP_RET_ERRNO = 0x00050001;
+export const BPF_LD_W_ABS = 0x20;
+export const BPF_JMP_JEQ_K = 0x15;
+export const BPF_JMP_JSET_K = 0x45;
+export const BPF_RET_K = 0x06;
+export const WNOHANG = 1;
+export const ECHILD = 10;
+export const ESRCH = 3;
+export const SYS_PIDFD_SEND_SIGNAL = 424;
+export const SYS_PIDFD_OPEN = 434;
+export const EINTR = 4;
+export const POLLIN = 0x0001;
+export const POLLERR = 0x0008;
+export const POLLHUP = 0x0010;
+export const POLLNVAL = 0x0020;
+
+interface FilterInstruction {
+  readonly code: number;
+  readonly jt: number;
+  readonly jf: number;
+  readonly k: number;
+}
+
+export const libc = dlopen('libc.so.6', {
+  prctl: { args: ['i32', 'u64', 'u64', 'u64', 'u64'], returns: 'i32' },
+  syscall: {
+    args: ['i64', 'i64', 'i64', 'i64', 'i64', 'i64', 'i64'],
+    returns: 'i64',
+  },
+  waitpid: { args: ['i32', 'ptr', 'i32'], returns: 'i32' },
+  close: { args: ['i32'], returns: 'i32' },
+  __errno_location: { args: [], returns: 'ptr' },
+  poll: { args: ['ptr', 'u64', 'i32'], returns: 'i32' },
+});
+export const native = libc.symbols;
+export function errno(): number {
+  const address = native.__errno_location();
+  return new Int32Array(toArrayBuffer(address, 0, 4))[0] ?? 0;
+}
+
+export function pidfdOpen(pid: number): number {
+  return Number(native.syscall(SYS_PIDFD_OPEN, pid, 0, 0, 0, 0, 0));
+}
+
+export function pidfdSendSignal(pidfd: number, signal: number): number {
+  return Number(native.syscall(SYS_PIDFD_SEND_SIGNAL, pidfd, signal, 0, 0, 0, 0));
+}
+
+export function pidfdAlive(pidfd: number): boolean {
+  const result = pidfdSendSignal(pidfd, 0);
+  if (result === 0) return true;
+  if (errno() === ESRCH) return false;
+  throw new Error('pidfd identity liveness probe failed');
+}
+export function installSupervisorProtection(supervisorPid: number): void {
+  const profile =
+    process.arch === 'x64'
+      ? {
+          auditArch: 0xc000003e,
+          kill: 62,
+          tkill: 200,
+          tgkill: 234,
+          rtSigqueueinfo: 129,
+          rtTgsigqueueinfo: 297,
+          prlimit64: 302,
+          schedulerControls: [141, 142, 144, 203, 251, 314],
+        }
+      : {
+          auditArch: 0xc00000b7,
+          kill: 129,
+          tkill: 130,
+          tgkill: 131,
+          rtSigqueueinfo: 138,
+          rtTgsigqueueinfo: 240,
+          prlimit64: 261,
+          schedulerControls: [140, 118, 119, 122, 30, 274],
+        };
+  const allow: FilterInstruction = { code: BPF_RET_K, jt: 0, jf: 0, k: SECCOMP_RET_ALLOW };
+  const deny: FilterInstruction = { code: BPF_RET_K, jt: 0, jf: 0, k: SECCOMP_RET_ERRNO };
+  const exactTarget = (): FilterInstruction[] => [
+    { code: BPF_LD_W_ABS, jt: 0, jf: 0, k: 16 },
+    { code: BPF_JMP_JEQ_K, jt: 1, jf: 0, k: supervisorPid },
+    allow,
+    deny,
+  ];
+  const supervisorTids = readdirSync(`/proc/${supervisorPid}/task`)
+    .map(Number)
+    .filter((tid) => Number.isSafeInteger(tid) && tid > 1);
+  if (!supervisorTids.includes(supervisorPid) || supervisorTids.length > 240) {
+    throw new Error('supervisor thread identities unavailable');
+  }
+  const exactThreadTarget: FilterInstruction[] = [
+    { code: BPF_LD_W_ABS, jt: 0, jf: 0, k: 16 },
+    ...supervisorTids.map((tid, index) => ({
+      code: BPF_JMP_JEQ_K,
+      jt: supervisorTids.length - index,
+      jf: 0,
+      k: tid,
+    })),
+    allow,
+    deny,
+  ];
+  const supervisorStat = readFileSync(`/proc/${supervisorPid}/stat`, 'utf8');
+  const close = supervisorStat.lastIndexOf(')');
+  const supervisorProcessGroup = Number(
+    close < 0
+      ? undefined
+      : supervisorStat
+          .slice(close + 2)
+          .trim()
+          .split(/\s+/)[2]
+  );
+  if (!Number.isSafeInteger(supervisorProcessGroup) || supervisorProcessGroup <= 1) {
+    throw new Error('supervisor process-group identity unavailable');
+  }
+  const killTargets = [0xffffffff, -supervisorProcessGroup >>> 0, ...supervisorTids];
+  const killTarget: FilterInstruction[] = [
+    { code: BPF_LD_W_ABS, jt: 0, jf: 0, k: 16 },
+    ...killTargets.map((target, index) => ({
+      code: BPF_JMP_JEQ_K,
+      jt: killTargets.length - index,
+      jf: 0,
+      k: target,
+    })),
+    allow,
+    deny,
+  ];
+  const instructions: FilterInstruction[] = [
+    { code: BPF_LD_W_ABS, jt: 0, jf: 0, k: 4 },
+    { code: BPF_JMP_JEQ_K, jt: 1, jf: 0, k: profile.auditArch },
+    deny,
+    { code: BPF_LD_W_ABS, jt: 0, jf: 0, k: 0 },
+    { code: BPF_JMP_JSET_K, jt: 0, jf: 1, k: 0x40000000 },
+    deny,
+  ];
+  for (const [syscall, block] of [
+    [profile.kill, killTarget],
+    [profile.tkill, [deny]],
+    [profile.tgkill, exactTarget()],
+    [profile.rtSigqueueinfo, exactThreadTarget],
+    [profile.rtTgsigqueueinfo, exactTarget()],
+    [profile.prlimit64, exactThreadTarget],
+    [SYS_PIDFD_OPEN, exactThreadTarget],
+  ] as const) {
+    instructions.push({ code: BPF_JMP_JEQ_K, jt: 0, jf: block.length, k: syscall }, ...block);
+  }
+  for (const syscall of profile.schedulerControls) {
+    instructions.push({ code: BPF_JMP_JEQ_K, jt: 0, jf: 1, k: syscall }, deny);
+  }
+  instructions.push(allow);
+
+  const filter = Buffer.alloc(instructions.length * 8);
+  instructions.forEach((instruction, index) => {
+    const offset = index * 8;
+    filter.writeUInt16LE(instruction.code, offset);
+    filter.writeUInt8(instruction.jt, offset + 2);
+    filter.writeUInt8(instruction.jf, offset + 3);
+    filter.writeUInt32LE(instruction.k >>> 0, offset + 4);
+  });
+  const program = Buffer.alloc(16);
+  program.writeUInt16LE(instructions.length, 0);
+  program.writeBigUInt64LE(BigInt(ptr(filter)), 8);
+  if (
+    native.prctl(PR_SET_NO_NEW_PRIVS, 1, 0, 0, 0) !== 0 ||
+    native.prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, ptr(program), 0, 0) !== 0
+  ) {
+    throw new Error('seccomp supervisor protection unavailable');
+  }
+}

package/scripts/omp/host-supervisor-tracker.ts

@@ -0,0 +1,258 @@
+/// <reference path="./bun-ffi.d.ts" />
+
+import { readFileSync, readdirSync } from 'node:fs';
+import { ptr } from 'bun:ffi';
+
+import {
+  ECHILD,
+  ESRCH,
+  WNOHANG,
+  errno,
+  native,
+  pidfdAlive,
+  pidfdOpen,
+  pidfdSendSignal,
+} from './host-supervisor-native';
+
+type StableIdentity = {
+  pid: number;
+  startTime: string;
+  parentPid: number;
+  parentStartTime: string;
+  pidfd: number;
+};
+
+const identities = new Map<number, StableIdentity>();
+let maxTrackedIdentities = 4_096;
+let semanticRootPid: number | undefined;
+let supervisorStartTime: string | undefined;
+
+interface ProcIdentity {
+  readonly state: string;
+  readonly parentPid: number;
+  readonly startTime: string;
+}
+
+export function processIdentity(pid: number): ProcIdentity | undefined {
+  try {
+    const source = readFileSync(`/proc/${pid}/stat`, 'utf8');
+    const close = source.lastIndexOf(')');
+    if (close < 0) return undefined;
+    const fields = source
+      .slice(close + 2)
+      .trim()
+      .split(/\s+/);
+    const state = fields[0];
+    const parentPid = Number(fields[1]);
+    const startTime = fields[19];
+    if (
+      state === undefined ||
+      !Number.isSafeInteger(parentPid) ||
+      parentPid < 0 ||
+      startTime === undefined
+    )
+      return undefined;
+    return { state, parentPid, startTime };
+  } catch {
+    return undefined;
+  }
+}
+
+export function processStartTime(pid: number): string | undefined {
+  return processIdentity(pid)?.startTime;
+}
+
+function childPids(pid: number): number[] {
+  const children = new Set<number>();
+  let tasks: string[];
+  try {
+    tasks = readdirSync(`/proc/${pid}/task`);
+  } catch {
+    return [];
+  }
+  for (const task of tasks) {
+    try {
+      for (const token of readFileSync(`/proc/${pid}/task/${task}/children`, 'utf8')
+        .trim()
+        .split(/\s+/)) {
+        const childPid = Number(token);
+        if (Number.isSafeInteger(childPid) && childPid > 1) children.add(childPid);
+      }
+    } catch {
+      // A thread may exit between listing and reading; kernel child ownership remains authoritative.
+    }
+  }
+  return [...children];
+}
+
+function openStableIdentity(
+  pid: number,
+  owner: {
+    readonly pid: number;
+    readonly startTime: string;
+    readonly pidfd?: number;
+  }
+): StableIdentity | undefined {
+  if (owner.pidfd !== undefined && !pidfdAlive(owner.pidfd)) return undefined;
+  const ownerBefore = processIdentity(owner.pid);
+  const before = processIdentity(pid);
+  if (
+    ownerBefore?.startTime !== owner.startTime ||
+    before === undefined ||
+    before.state === 'Z' ||
+    before.parentPid !== owner.pid
+  )
+    return undefined;
+  const pidfd = pidfdOpen(pid);
+  if (pidfd < 0) {
+    if (errno() === ESRCH && processIdentity(pid) === undefined) return undefined;
+    throw new Error('pidfd_open unavailable for an owned process');
+  }
+  const ownerAfter = processIdentity(owner.pid);
+  if (owner.pidfd !== undefined && !pidfdAlive(owner.pidfd)) {
+    native.close(pidfd);
+    return undefined;
+  }
+  const after = processIdentity(pid);
+  if (
+    ownerAfter?.startTime !== owner.startTime ||
+    after?.startTime !== before.startTime ||
+    after.state === 'Z' ||
+    after.parentPid !== owner.pid
+  ) {
+    native.close(pidfd);
+    return undefined;
+  }
+  return {
+    pid,
+    startTime: before.startTime,
+    parentPid: owner.pid,
+    parentStartTime: owner.startTime,
+    pidfd,
+  };
+}
+
+function retireExitedIdentities(): void {
+  const status = new Int32Array(1);
+  for (const identity of identities.values()) {
+    if (identity.pid !== semanticRootPid) {
+      const reaped = native.waitpid(identity.pid, ptr(status), WNOHANG);
+      if (reaped < 0 && errno() !== ECHILD) {
+        throw new Error('waitpid failed while retiring an owned identity');
+      }
+    }
+    const probe = pidfdSendSignal(identity.pidfd, 0);
+    if (probe < 0 && errno() === ESRCH) {
+      native.close(identity.pidfd);
+      identities.delete(identity.pid);
+    } else if (probe < 0) {
+      throw new Error('pidfd identity liveness probe failed');
+    }
+  }
+}
+
+export function discoverOwnedProcesses(): void {
+  retireExitedIdentities();
+  if (supervisorStartTime === undefined) throw new Error('supervisor identity unavailable');
+  const queue: Array<{ pid: number; startTime: string; pidfd?: number }> = [
+    { pid: process.pid, startTime: supervisorStartTime },
+  ];
+  for (const identity of identities.values()) {
+    queue.push({
+      pid: identity.pid,
+      startTime: identity.startTime,
+      pidfd: identity.pidfd,
+    });
+  }
+  const visited = new Set<number>();
+  while (queue.length > 0) {
+    const owner = queue.shift();
+    if (owner === undefined || visited.has(owner.pid)) continue;
+    visited.add(owner.pid);
+    if (processStartTime(owner.pid) !== owner.startTime) continue;
+    if (owner.pidfd !== undefined && !pidfdAlive(owner.pidfd)) continue;
+    for (const childPid of childPids(owner.pid)) {
+      let identity = identities.get(childPid);
+      if (identity !== undefined && processStartTime(childPid) !== identity.startTime) {
+        native.close(identity.pidfd);
+        identities.delete(childPid);
+        identity = undefined;
+      }
+      if (identity === undefined) {
+        if (identities.size >= maxTrackedIdentities) {
+          throw new Error('owned process identity capacity exceeded');
+        }
+        identity = openStableIdentity(childPid, owner);
+        if (identity !== undefined) identities.set(childPid, identity);
+      }
+      if (identity !== undefined) {
+        queue.push({
+          pid: identity.pid,
+          startTime: identity.startTime,
+          pidfd: identity.pidfd,
+        });
+      }
+    }
+  }
+  retireExitedIdentities();
+}
+
+export function signalTracked(signal: number): void {
+  for (const identity of identities.values()) {
+    const result = pidfdSendSignal(identity.pidfd, signal);
+    if (result < 0 && errno() === ESRCH) {
+      native.close(identity.pidfd);
+      identities.delete(identity.pid);
+    } else if (result < 0) {
+      throw new Error('pidfd_send_signal failed for an owned process');
+    }
+  }
+}
+
+export function signalOwned(signal: number): void {
+  discoverOwnedProcesses();
+  signalTracked(signal);
+}
+
+export function reapExitedOwned(rootPid: number): void {
+  const status = new Int32Array(1);
+  for (const identity of identities.values()) {
+    if (identity.pid === rootPid) continue;
+    const result = native.waitpid(identity.pid, ptr(status), WNOHANG);
+    if (result < 0 && errno() !== ECHILD) {
+      throw new Error('waitpid failed for an owned process');
+    }
+  }
+}
+
+export function ownershipEmpty(): boolean {
+  const status = new Int32Array(1);
+  for (;;) {
+    const result = native.waitpid(-1, ptr(status), WNOHANG);
+    if (result > 0) continue;
+    if (result === 0) return false;
+    if (errno() === ECHILD) return true;
+    throw new Error('kernel child ownership could not be determined');
+  }
+}
+export function initializeProcessTracker(startTime: string, identityCap: number): void {
+  supervisorStartTime = startTime;
+  maxTrackedIdentities = identityCap;
+}
+
+export function trackSemanticRoot(pid: number): boolean {
+  semanticRootPid = pid;
+  if (supervisorStartTime === undefined) throw new Error('supervisor identity unavailable');
+  const rootIdentity = openStableIdentity(pid, {
+    pid: process.pid,
+    startTime: supervisorStartTime,
+  });
+  if (rootIdentity === undefined) return false;
+  identities.set(rootIdentity.pid, rootIdentity);
+  return true;
+}
+
+export function closeTrackedIdentities(): void {
+  for (const identity of identities.values()) native.close(identity.pidfd);
+  identities.clear();
+}