pantheon-opencode 1.5.0-beta.2 → 1.5.0-beta.20

package/src/pantheon/file-persistence.ts

@@ -1,91 +1,238 @@
 /**
  * File-based persistence adapter for the BackgroundJobBoard.
  *
- * Stores all jobs in a single `state.json` file using atomic writes
- * (write to `state.json.tmp` then rename) to prevent partial writes
- * from crashes.
+ * Stores all jobs in a single `state.json` file. Writes are crash-safe:
+ * the payload is written to a UNIQUE temp file, fsynced, then renamed over
+ * the destination. Writes to the same path are serialized through an
+ * in-process queue so two logical writers (plugin × native) cannot
+ * interleave and corrupt the JSON or race the rename.
+ *
+ * Reads are corruption-tolerant: a malformed `state.json` is moved aside to
+ * `<state>.corrupt-<ts>`, a clear log is emitted, and whatever complete
+ * records can be salvaged from the array are returned — never a throw, so
+ * callers (delete/prune/recover) cannot get stuck in a retry loop.
  *
  * @module file-persistence
  */
 
-import { mkdir, readFile, rename, writeFile } from 'node:fs/promises'
-import { dirname } from 'node:path'
+import { mkdir, open, readFile, rename, unlink } from 'node:fs/promises'
+import { dirname, resolve } from 'node:path'
 
 import type { BackgroundJobRecord, PersistenceAdapter } from './background-job-board.ts'
+import { salvageRecords } from './file-persistence-salvage.ts'
+import { createPantheonLogger } from './logger.ts'
+
+export { salvageRecords } from './file-persistence-salvage.ts'
+
+const log = createPantheonLogger({ module: 'FilePersistence' })
 
 /** Default path for the state file. */
 const DEFAULT_STATE_PATH = '.pantheon/board/state.json'
 
+/** Max rename attempts after an ENOENT before giving up (dir/tmp recreated each try). */
+const RENAME_MAX_ATTEMPTS = 3
+
+/** Minimal file handle surface used to fsync the temp file before rename. */
+export interface PersistenceFileHandle {
+  writeFile(data: string, encoding: 'utf-8'): Promise<void>
+  sync(): Promise<void>
+  close(): Promise<void>
+}
+
+/**
+ * Filesystem operations used by the adapter. Injectable so tests can fault
+ * inject a failing `rename` (ENOENT) deterministically.
+ */
+export interface PersistenceFsOps {
+  mkdir(dir: string): Promise<void>
+  readFile(path: string, encoding: 'utf-8'): Promise<string>
+  rename(from: string, to: string): Promise<void>
+  openForWrite(path: string): Promise<PersistenceFileHandle>
+  unlink(path: string): Promise<void>
+}
+
+/** Real Node.js filesystem implementation (the default). */
+const defaultFsOps: PersistenceFsOps = {
+  mkdir: async (dir) => {
+    await mkdir(dir, { recursive: true })
+  },
+  readFile: (path, encoding) => readFile(path, encoding),
+  rename: (from, to) => rename(from, to),
+  openForWrite: (path) => open(path, 'w'),
+  unlink: (path) => unlink(path),
+}
+
+function isEnoent(err: unknown): boolean {
+  return err instanceof Error && 'code' in err && (err as NodeJS.ErrnoException).code === 'ENOENT'
+}
+
+/**
+ * In-process write queues keyed by absolute state path. Shared across
+ * adapter INSTANCES so a plugin adapter and a native adapter pointing at the
+ * same file serialize their read-modify-write cycles.
+ */
+const writeQueues = new Map<string, Promise<unknown>>()
+
+function enqueueWrite<T>(key: string, task: () => Promise<T>): Promise<T> {
+  const previous = writeQueues.get(key) ?? Promise.resolve()
+  const run = previous.then(task, task)
+  writeQueues.set(
+    key,
+    run.then(
+      () => undefined,
+      () => undefined,
+    ),
+  )
+  return run
+}
+
 /**
  * File-based persistence adapter.
  *
- * All jobs are stored in a single JSON array in `statePath`.
- * Writes are atomic: content is written to a `.tmp` file, then renamed.
- *
- * The board's in-memory `this.jobs` Map is the source of truth —
- * this file is a crash-recovery snapshot. `deleteJob()` removes the
- * record from the snapshot so pruned/reconciled jobs don't resurface
- * after a restart.
+ * All jobs are stored in a single JSON array in `statePath`. Writes are
+ * atomic and serialized (unique tmp + fsync + rename, with ENOENT retry).
+ * Corrupt state is backed up and salvaged instead of throwing.
  */
 export class FilePersistenceAdapter implements PersistenceAdapter {
   private readonly statePath: string
   private readonly dir: string
+  private readonly ops: PersistenceFsOps
+  private readonly lockKey: string
+  private tmpCounter = 0
 
   /**
    * @param statePath  Path to the state JSON file (default: `.pantheon/board/state.json`)
+   * @param ops        Filesystem operations (defaults to real Node.js fs; injectable for tests)
    */
-  constructor(statePath?: string) {
+  constructor(statePath?: string, ops: PersistenceFsOps = defaultFsOps) {
     this.statePath = statePath ?? DEFAULT_STATE_PATH
     this.dir = dirname(this.statePath)
+    this.ops = ops
+    this.lockKey = resolve(this.statePath)
   }
 
   /** Ensure the parent directory exists. */
   private async ensureDir(): Promise<void> {
-    await mkdir(this.dir, { recursive: true })
+    await this.ops.mkdir(this.dir)
   }
 
-  /** Path to the atomic-write temp file. */
-  private get tmpPath(): string {
-    return this.statePath + '.tmp'
+  /** Unique temp path per write — prevents two writers racing the same tmp. */
+  private makeTmpPath(): string {
+    this.tmpCounter += 1
+    const unique = `${process.pid}.${this.tmpCounter}.${Math.random().toString(36).slice(2, 8)}`
+    return `${this.statePath}.${unique}.tmp`
   }
 
   /**
    * Read all jobs from the state file.
-   * Returns `null` if the file doesn't exist (first run / no jobs yet).
+   *
+   * Return contract distinguishes three failure modes:
+   * - absent file (ENOENT) → `[]` (first run / no jobs yet);
+   * - corrupt content → quarantine + `salvageRecords()` (best-effort recovery);
+   * - non-ENOENT IO error (e.g. EIO) → `null`, signalling the read failed.
+   *
+   * Callers doing read-modify-write MUST abort on `null` so a failed read
+   * cannot overwrite the on-disk state with a partial snapshot.
    */
   private async readState(): Promise<BackgroundJobRecord[] | null> {
+    let content: string
     try {
-      const content = await readFile(this.statePath, 'utf-8')
-      return JSON.parse(content) as BackgroundJobRecord[]
+      content = await this.ops.readFile(this.statePath, 'utf-8')
     } catch (err: unknown) {
-      if (
-        err instanceof Error &&
-        'code' in err &&
-        (err as NodeJS.ErrnoException).code === 'ENOENT'
-      ) {
-        return null
+      if (isEnoent(err)) return []
+      log.error(`[FilePersistence] Failed to read ${this.statePath}:`, err)
+      return null
+    }
+
+    try {
+      const parsed: unknown = JSON.parse(content)
+      if (!Array.isArray(parsed)) {
+        throw new Error('state.json is not a JSON array')
       }
-      throw err
+      return parsed as BackgroundJobRecord[]
+    } catch (err: unknown) {
+      await this.quarantineCorrupt(err)
+      const salvaged = salvageRecords(content)
+      log.warn(
+        `[FilePersistence] Corrupt ${this.statePath} — recovered ${salvaged.length} record(s)`,
+      )
+      return salvaged
+    }
+  }
+
+  /** Move a corrupt state.json aside so the next write starts from a clean file. */
+  private async quarantineCorrupt(cause: unknown): Promise<void> {
+    const backupPath = `${this.statePath}.corrupt-${Date.now()}`
+    try {
+      await this.ops.rename(this.statePath, backupPath)
+      log.error(`[FilePersistence] Corrupt ${this.statePath} backed up to ${backupPath}:`, cause)
+    } catch (err: unknown) {
+      log.error(
+        `[FilePersistence] Could not back up corrupt ${this.statePath} — continuing with salvaged state:`,
+        err,
+      )
     }
   }
 
-  /** Write the full state array atomically (tmp + rename). */
+  /** Write the full state array: unique tmp + fsync + rename (with ENOENT retry). */
   private async writeState(records: BackgroundJobRecord[]): Promise<void> {
-    await this.ensureDir()
     const content = JSON.stringify(records, null, 2)
-    await writeFile(this.tmpPath, content, 'utf-8')
-    await rename(this.tmpPath, this.statePath)
+    const tmpPath = this.makeTmpPath()
+    let lastError: unknown
+
+    for (let attempt = 1; attempt <= RENAME_MAX_ATTEMPTS; attempt++) {
+      try {
+        await this.ensureDir()
+        const handle = await this.ops.openForWrite(tmpPath)
+        try {
+          await handle.writeFile(content, 'utf-8')
+          await handle.sync()
+        } finally {
+          await handle.close()
+        }
+        await this.ops.rename(tmpPath, this.statePath)
+        return
+      } catch (err: unknown) {
+        lastError = err
+        if (!isEnoent(err)) break
+        log.warn(
+          `[FilePersistence] rename ENOENT for ${this.statePath} ` +
+            `(attempt ${attempt}/${RENAME_MAX_ATTEMPTS}) — recreating dir and retrying`,
+        )
+        await this.safeUnlink(tmpPath)
+      }
+    }
+
+    await this.safeUnlink(tmpPath)
+    throw lastError instanceof Error ? lastError : new Error(String(lastError))
   }
 
-  async saveJob(record: BackgroundJobRecord): Promise<void> {
-    const records = (await this.readState()) ?? []
-    const idx = records.findIndex((r) => r.taskID === record.taskID)
-    if (idx >= 0) {
-      records[idx] = record
-    } else {
-      records.push(record)
+  private async safeUnlink(path: string): Promise<void> {
+    try {
+      await this.ops.unlink(path)
+    } catch {
+      // Best-effort temp cleanup — absent file is fine.
     }
-    await this.writeState(records)
+  }
+
+  async saveJob(record: BackgroundJobRecord): Promise<void> {
+    await enqueueWrite(this.lockKey, async () => {
+      const records = await this.readState()
+      if (records === null) {
+        log.error(
+          `[FilePersistence] Aborting saveJob(${record.taskID}): could not read ` +
+            `${this.statePath} — refusing to overwrite state with a partial snapshot`,
+        )
+        return
+      }
+      const idx = records.findIndex((r) => r.taskID === record.taskID)
+      if (idx >= 0) {
+        records[idx] = record
+      } else {
+        records.push(record)
+      }
+      await this.writeState(records)
+    })
   }
 
   async loadAllJobs(): Promise<BackgroundJobRecord[]> {
@@ -93,11 +240,13 @@ export class FilePersistenceAdapter implements PersistenceAdapter {
   }
 
   async deleteJob(taskID: string): Promise<void> {
-    const records = await this.readState()
-    if (!records) return
-    const idx = records.findIndex((r) => r.taskID === taskID)
-    if (idx < 0) return
-    records.splice(idx, 1)
-    await this.writeState(records)
+    await enqueueWrite(this.lockKey, async () => {
+      const records = await this.readState()
+      if (!records) return
+      const idx = records.findIndex((r) => r.taskID === taskID)
+      if (idx < 0) return
+      records.splice(idx, 1)
+      await this.writeState(records)
+    })
   }
 }

package/src/pantheon/goal-loop.ts

@@ -17,11 +17,11 @@
 import { z } from 'zod'
 
 import type { BackgroundJobBoard } from './background-job-board.ts'
-import type { ToolContextLike } from './delegation.ts'
 import { GoalStore } from './goal-store.ts'
 import { createPantheonLogger } from './logger.ts'
 import { safeSessionPath } from './session-guard.ts'
 import type { TodoEnforcerMessage } from './todo-enforcer.ts'
+import type { ToolContextLike } from './tool-context.ts'
 
 // Silence-by-default TUI policy (pantheon-hooks L42-58): warn → hooks.log,
 // console echo opt-in via PANTHEON_HOOKS_LOG=1. `deps.logger` stays for tests.

package/src/pantheon/goal-store.ts

@@ -15,7 +15,7 @@
 import { mkdir, readFile, rename, writeFile } from 'node:fs/promises'
 import { join } from 'node:path'
 
-import { assertSafeParentSessionID } from './delegation-finalize.ts'
+import { assertSafeParentSessionID } from './session-id.ts'
 
 export type GoalStatus = 'pending' | 'in_progress' | 'done'
 

package/src/pantheon/idle-continuation.ts

@@ -5,9 +5,8 @@
  * Priority: an ACTIVE GOAL owns the idle — `GoalLoop.onIdle` continues the
  * goal. Without an active goal, the TODO enforcer gets the idle (it
  * self-guards on its own enabled flag + guards). Board-child sessions never
- * reach the dispatcher — the plugin's event hook routes those to the
- * delegation finalize path first (`handleDelegationEvent` returns true) and
- * only calls the dispatcher on the `!delegated` branch.
+ * reach the dispatcher — the plugin's event hook owns board transitions and
+ * only calls the dispatcher for non-board sessions.
  *
  * Independently testable — the loop and enforcer are structural interfaces;
  * the real GoalLoop/TodoEnforcer satisfy them.
@@ -34,9 +33,8 @@ export interface IdleDispatcher {
 }
 
 /**
- * Build the idle router. The plugin event hook calls this only on the
- * `!delegated` branch of `handleDelegationEvent`, so board children never
- * arrive here.
+ * Build the idle router. The plugin event hook calls this only for non-board
+ * sessions, so board children never arrive here.
  */
 export function createIdleDispatcher(deps: {
   goalLoop: GoalLoopLike

package/src/pantheon/model-command.ts

@@ -23,8 +23,6 @@ import { lstat, mkdir, open, rename, unlink } from 'node:fs/promises'
 import { homedir } from 'node:os'
 import { basename, dirname, join, resolve } from 'node:path'
 import { z } from 'zod'
-
-import type { ToolContextLike } from './delegation.ts'
 import {
   capabilityEntry,
   hasVision,
@@ -32,6 +30,7 @@ import {
   normalizeCapability,
   resolveActivePreset,
 } from './presets.mjs'
+import type { ToolContextLike } from './tool-context.ts'
 
 export type ModelScope = 'project' | 'global'
 export type ModelAction = 'status' | 'show' | 'set' | 'reset'

package/src/pantheon/native-task-status.ts

@@ -0,0 +1,139 @@
+/**
+ * Native Task Status — classifies BackgroundJobRecord results from native
+ * task() delegation into actionable status codes.
+ *
+ * Pure module — zero external dependencies. Consumed by the tool-ceiling and
+ * cost layers to decide retry/skip/escalate strategy.
+ *
+ * @module native-task-status
+ */
+
+import type { BackgroundJobRecord } from './background-job-board.ts'
+
+// ─── Types ─────────────────────────────────────────────────────────────
+
+/** Actionable status for a native task() delegation result. */
+export type NativeTaskStatus =
+  | 'OK'
+  | 'UNSUPPORTED'
+  | 'UNAVAILABLE'
+  | 'INVALID_INPUT'
+  | 'INVALID_STATE'
+  | 'CONFLICT'
+  | 'CORRUPT_DATA'
+  | 'TIMEOUT'
+  | 'ESCALATE'
+
+// ─── Helpers ───────────────────────────────────────────────────────────
+
+/** Check if a string contains any of the given substrings (case-insensitive). */
+function containsAny(text: string | undefined, patterns: readonly string[]): boolean {
+  if (text == null) return false
+  const lower = text.toLowerCase()
+  return patterns.some((p) => lower.includes(p.toLowerCase()))
+}
+
+/** Check if a job's output is empty or whitespace-only. */
+function isOutputEmpty(job: BackgroundJobRecord): boolean {
+  const summary = job.resultSummary
+  if (summary == null) return true
+  if (typeof summary !== 'string') return true
+  return summary.trim() === ''
+}
+
+// ─── Implementation ────────────────────────────────────────────────────
+
+/**
+ * Classify a BackgroundJobRecord result into a NativeTaskStatus.
+ *
+ * Priority order (first match wins):
+ * 1. verifyError and lastStatusError patterns → UNSUPPORTED, CONFLICT,
+ *    INVALID_INPUT, INVALID_STATE, CORRUPT_DATA, ESCALATE
+ * 2. state === startup_failed or timedOut → TIMEOUT
+ * 3. state === completed + non-empty output → OK
+ * 4. state === completed + empty output → UNAVAILABLE (silent failure / admission rejection)
+ * 5. state === error → UNAVAILABLE (safe default for provider/infra errors)
+ * 6. Fallback → UNAVAILABLE
+ */
+export function classifyNativeResult(
+  job: BackgroundJobRecord,
+  verifyError?: string,
+): NativeTaskStatus {
+  const statusError = [verifyError, job.lastStatusError]
+    .filter((value): value is string => value != null && value.length > 0)
+    .join(' ')
+
+  // A missing native task API is terminal and must not be retried or sent
+  // through a fallback model. Provider/transport failures remain unavailable.
+  if (
+    containsAny(statusError, [
+      'api unavailable',
+      'api not available',
+      'api missing',
+      'method not found',
+      'unknown method',
+      'not supported',
+      'unsupported',
+      'does not support',
+      'task() is not available',
+    ])
+  ) {
+    return 'UNSUPPORTED'
+  }
+
+  // ── Phase 1: verifyError explicit signals (highest priority) ───────
+
+  if (verifyError != null && verifyError.length > 0) {
+    // CONFLICT: canDispatch=false or concurrency exceeded
+    if (containsAny(verifyError, ['canDispatch', 'concurrency', 'conflict'])) {
+      return 'CONFLICT'
+    }
+
+    // INVALID_INPUT: agent not recognized / invalid
+    if (containsAny(verifyError, ['invalid agent', 'agent not found', 'unknown agent'])) {
+      return 'INVALID_INPUT'
+    }
+
+    // INVALID_STATE: child already in terminal state
+    if (containsAny(verifyError, ['already terminal', 'already in terminal', 'invalid state'])) {
+      return 'INVALID_STATE'
+    }
+
+    // CORRUPT_DATA: output can't be parsed / corrupted
+    if (containsAny(verifyError, ['corrupt', 'parse failed', 'malformed', 'invalid format'])) {
+      return 'CORRUPT_DATA'
+    }
+
+    // ESCALATE: unrecoverable failure
+    if (containsAny(verifyError, ['unrecoverable', 'fatal', 'max retries exceeded'])) {
+      return 'ESCALATE'
+    }
+  }
+
+  // ── Phase 2: state-based classification ────────────────────────────
+
+  // TIMEOUT: startup failure or timed out
+  if (job.state === 'startup_failed' || job.state === 'startup_unknown' || job.timedOut) {
+    return 'TIMEOUT'
+  }
+
+  // ── Phase 3: output-based classification ───────────────────────────
+
+  if (job.state === 'completed') {
+    if (!isOutputEmpty(job)) {
+      return 'OK'
+    }
+    // completed but empty → silent failure (BackendAdmissionRejected pattern)
+    return 'UNAVAILABLE'
+  }
+
+  // ── Phase 4: error state fallback ──────────────────────────────────
+
+  if (job.state === 'error') {
+    return 'UNAVAILABLE'
+  }
+
+  // ── Fallback ───────────────────────────────────────────────────────
+
+  return 'UNAVAILABLE'
+}

package/src/pantheon/presets.d.mts

@@ -104,26 +104,6 @@ export interface RoutingRetryPolicyOptions {
   logger?: { warn?: (msg: string) => void }
 }
 
-/**
- * R1: per-error-type retry policy from routing.yml `retry_policy`
- * (auth/rate_limit/timeout/other → max retries). Fail-open → null.
- */
-export declare function loadRoutingRetryPolicy(
-  options?: RoutingRetryPolicyOptions,
-): Record<string, number> | null
-
-export interface RoutingCooldownResult {
-  allowed_fails: number
-  cooldown_time_seconds: number
-}
-
-/**
- * R1: provider cooldown config from routing.yml `cooldown`. Fail-open → null.
- */
-export declare function loadRoutingCooldown(
-  options?: RoutingRetryPolicyOptions,
-): RoutingCooldownResult | null
-
 /**
  * R4: per-agent step caps from routing.yml `agents.<name>.max_steps`.
  * Fail-open → {} (no agent capped).

package/src/pantheon/presets.mjs

@@ -213,70 +213,6 @@ function loadRoutingYaml(routingPath) {
   return routing && typeof routing === 'object' ? routing : null
 }
 
-const RETRY_ERROR_TYPES = new Set(['auth', 'rate_limit', 'timeout', 'other'])
-
-/**
- * Load the R1 per-error-type retry policy from routing.yml (`retry_policy:`).
- * Fail-open: missing/unparseable config yields null (the caller falls back
- * to DEFAULT_RETRY_POLICY) and warns via the optional logger.
- *
- * @param {object} [opts]
- * @param {string} [opts.routingPath]
- * @param {{warn?: Function}} [opts.logger]
- * @returns {Record<string, number>|null} error-type → max retries
- */
-export function loadRoutingRetryPolicy({ routingPath, logger = console } = {}) {
-  try {
-    const routing = loadRoutingYaml(routingPath)
-    const policy = routing?.retry_policy
-    if (!policy || typeof policy !== 'object' || Array.isArray(policy)) return null
-    const out = {}
-    for (const [type, max] of Object.entries(policy)) {
-      if (RETRY_ERROR_TYPES.has(type) && Number.isSafeInteger(max) && max >= 0) {
-        out[type] = max
-      }
-    }
-    return Object.keys(out).length > 0 ? out : null
-  } catch (err) {
-    const reason = err instanceof Error ? err.message : String(err)
-    logger.warn?.(`presets: routing.yml retry_policy unavailable (${reason})`)
-    return null
-  }
-}
-
-/**
- * Load the R1 provider cooldown config from routing.yml (`cooldown:`).
- * Fail-open: missing/unparseable config yields null (caller falls back to
- * DEFAULT_COOLDOWN).
- *
- * @param {object} [opts]
- * @param {string} [opts.routingPath]
- * @param {{warn?: Function}} [opts.logger]
- * @returns {{allowed_fails: number, cooldown_time_seconds: number}|null}
- */
-export function loadRoutingCooldown({ routingPath, logger = console } = {}) {
-  try {
-    const routing = loadRoutingYaml(routingPath)
-    const cooldown = routing?.cooldown
-    if (!cooldown || typeof cooldown !== 'object' || Array.isArray(cooldown)) return null
-    const allowedFails = cooldown.allowed_fails
-    const cooldownTimeSeconds = cooldown.cooldown_time_seconds
-    if (
-      !Number.isSafeInteger(allowedFails) ||
-      allowedFails < 1 ||
-      !Number.isSafeInteger(cooldownTimeSeconds) ||
-      cooldownTimeSeconds < 1
-    ) {
-      return null
-    }
-    return { allowed_fails: allowedFails, cooldown_time_seconds: cooldownTimeSeconds }
-  } catch (err) {
-    const reason = err instanceof Error ? err.message : String(err)
-    logger.warn?.(`presets: routing.yml cooldown unavailable (${reason})`)
-    return null
-  }
-}
-
 /**
  * Load the R4 per-agent step caps from routing.yml
  * (`agents.<name>.max_steps`). Fail-open: missing config yields {}.

package/src/pantheon/session-guard.ts

@@ -10,8 +10,8 @@
  * never throw, never send the placeholder).
  *
  * Mirrors the TUI's `src/plugins/tui/src/index.tsx` contract verbatim so both
- * sides agree on what "valid" means. The TUI file remains self-contained
- * (dist/tui.tsx is a raw copy, no relative imports), so its local copy is kept
+ * sides agree on what "valid" means. The TUI plugin ships as a bundle
+ * (dist/tui.js) without the src/pantheon tree, so its local copy is kept
  * in sync — this module is the shared source for `src/pantheon/*` and
  * `src/plugin.ts`.
  *

package/src/pantheon/session-id.ts

@@ -0,0 +1,30 @@
+/**
+ * Session ID safety — reject session IDs that could escape a per-session
+ * output directory.
+ *
+ * Shared helper for the file-backed stores that remain after the delegate
+ * removal (goal-store and friends) — it no longer lives alongside the
+ * deleted delegation module.
+ *
+ * `sessionID` is embedded in a path
+ * `<dir>/<sessionID>/file.json` — `path.join` does NOT strip `..`, so a
+ * traversing ID would write outside the sandbox. Call this BEFORE any path
+ * construction.
+ *
+ * @module session-id
+ */
+
+/**
+ * Reject session IDs that could escape the target directory.
+ *
+ * @throws {Error} When the ID contains `..`, `/`, or `\`.
+ */
+export function assertSafeParentSessionID(parentSessionID: string): void {
+  if (
+    parentSessionID.includes('..') ||
+    parentSessionID.includes('/') ||
+    parentSessionID.includes('\\')
+  ) {
+    throw new Error(`Invalid parentSessionID: ${parentSessionID}`)
+  }
+}