@relayflows/sdk 2.0.0 → 2.0.2

package/src/daemon-lifecycle.ts

@@ -0,0 +1,198 @@
+// Attach-or-spawn for relayflowd (kernel/DAEMON-LIFECYCLE.md §3).
+//
+// Lifecycle is not transport, so none of this lives in journal-client.ts:
+// putting spawn logic in the client would make every AgentWorker, tick runner
+// and demo conjure daemons as a side effect of connecting. The client stays
+// fail-closed with no retry and no spawn; this module only decides how the
+// socket gets there.
+
+import type { ChildProcess, SpawnOptions } from 'node:child_process';
+import { join, resolve } from 'node:path';
+import {
+  checkDaemon,
+  connectionPathFor,
+  DAEMON_LOG_FILE,
+  defaultDaemonLifecycleDeps,
+  socketPathFor,
+  type DaemonLifecycleDeps,
+  type DaemonState,
+} from './daemon-connection.js';
+import { RelayflowdNotFoundError } from './relayflowd-path.js';
+
+export * from './daemon-connection.js';
+
+/** `relayflowd serve` lost the singleton lock — someone else is serving (§3). */
+export const EXIT_ALREADY_SERVING = 3;
+
+/** §3: matches ../relay's DETACHED_START_READY_TIMEOUT_MS. */
+export const DEFAULT_START_TIMEOUT_MS = 10_000;
+/** §3: matches the existing poll in scripts/run-local-workflow.mjs:64-71. */
+export const START_POLL_INTERVAL_MS = 50;
+/** How much of relayflowd.log a `daemon_start_failed` refusal quotes. */
+const LOG_TAIL_BYTES = 4_096;
+
+export interface EnsureDaemonOptions {
+  /** `false` restores today's fail-closed behavior (`--no-spawn`). */
+  spawn?: boolean;
+  timeoutMs?: number;
+}
+
+/**
+ * §3's CLI algorithm. Attach if something is serving; otherwise spawn
+ * `relayflowd serve` detached and poll for it, bounded.
+ *
+ * The CLI never has to be clever here, and that is the load-bearing
+ * simplification: because the singleton mutex lives in the daemon
+ * (`flock` on `<data-dir>/relayflowd.lock`, §3), spawning when in doubt is
+ * always safe. A child that loses the race exits `EXIT_ALREADY_SERVING`
+ * having unlinked nothing, bound nothing and written nothing, and this loop
+ * keeps polling until the winner publishes.
+ *
+ * The CLI never terminates a daemon — not one it found, and not one it
+ * spawned.
+ */
+export async function ensureDaemon(
+  dataDir: string,
+  options: EnsureDaemonOptions = {},
+  deps: DaemonLifecycleDeps = defaultDaemonLifecycleDeps,
+): Promise<DaemonState> {
+  const resolvedDataDir = resolve(dataDir);
+  const maySpawn = options.spawn ?? true;
+  const timeoutMs = options.timeoutMs ?? DEFAULT_START_TIMEOUT_MS;
+
+  const first = await checkDaemon(resolvedDataDir, deps);
+  if (first.kind === 'attached' || first.kind === 'incompatible') return first;
+  if (!maySpawn) {
+    return {
+      kind: 'unavailable',
+      failure: 'daemon_unreachable',
+      message: first.kind === 'stale' ? first.message : 'no connection file and no listening socket',
+    };
+  }
+
+  // Only the corpse is removed, and only when nothing is serving and its pid
+  // is gone (§2 row 1). The other stale verdicts leave the file alone on
+  // purpose: a daemon mid-boot may be about to publish, and unlinking the
+  // winner's file would strand this poll loop. The booting daemon sweeps
+  // leftovers under the lock anyway (§1 step 3), which is the only place the
+  // removal is provably safe.
+  if (first.kind === 'stale' && first.reason === 'dead_pid_dead_socket') {
+    deps.removeFile(connectionPathFor(resolvedDataDir));
+  }
+
+  let binary: string;
+  try {
+    binary = deps.resolveBinary();
+  } catch (error) {
+    return {
+      kind: 'unavailable',
+      failure: 'relayflowd_not_found',
+      message: error instanceof RelayflowdNotFoundError || error instanceof Error
+        ? error.message
+        : 'relayflowd could not be located.',
+    };
+  }
+
+  deps.makeDirectory(resolvedDataDir);
+  const logPath = join(resolvedDataDir, DAEMON_LOG_FILE);
+  const child = spawnDaemon(binary, resolvedDataDir, logPath, deps);
+  return pollForDaemon(resolvedDataDir, child, logPath, timeoutMs, deps);
+}
+
+interface SpawnedDaemon {
+  exit: { code: number | null; signal: NodeJS.Signals | null } | undefined;
+  error: Error | undefined;
+}
+
+/**
+ * `detached: true` puts the child in its own session and process group. Both
+ * consequences are required: it outlives this CLI, and a Ctrl-C sent to the
+ * CLI's process group does not reach it.
+ *
+ * stdio never inherits the CLI's. A daemon holding the CLI's stdout would
+ * interleave its own output with `flows run --json`'s single report object,
+ * and would hold the pipe open after the CLI exits, hanging anything reading
+ * it. stderr goes to `<data-dir>/relayflowd.log` so a failed start has
+ * evidence to quote.
+ */
+function spawnDaemon(
+  binary: string,
+  dataDir: string,
+  logPath: string,
+  deps: DaemonLifecycleDeps,
+): SpawnedDaemon {
+  const state: SpawnedDaemon = { exit: undefined, error: undefined };
+  const log = deps.openAppend(logPath);
+  try {
+    const child = deps.spawnProcess(binary, ['--data-dir', dataDir, 'serve'], {
+      detached: true,
+      stdio: ['ignore', 'ignore', log],
+      env: process.env,
+      cwd: process.cwd(),
+    });
+    child.once('error', (error: Error) => {
+      state.error = error;
+    });
+    child.once('exit', (code: number | null, signal: NodeJS.Signals | null) => {
+      state.exit = { code, signal };
+    });
+    child.unref();
+  } finally {
+    // The child holds its own duplicate of this descriptor; keeping the
+    // parent's copy open would leak one per invocation.
+    deps.closeFd(log);
+  }
+  return state;
+}
+
+async function pollForDaemon(
+  dataDir: string,
+  child: SpawnedDaemon,
+  logPath: string,
+  timeoutMs: number,
+  deps: DaemonLifecycleDeps,
+): Promise<DaemonState> {
+  const deadline = deps.now() + timeoutMs;
+  for (;;) {
+    if (child.error !== undefined) {
+      return {
+        kind: 'unavailable',
+        failure: 'daemon_start_failed',
+        message: `relayflowd could not be started: ${child.error.message}`,
+      };
+    }
+    // §3 branch D.a: exit 3 means this child lost a benign race for the data
+    // dir's lock. The winner is coming up. Keep polling; do not respawn, and
+    // do not report failure.
+    if (
+      child.exit !== undefined
+      && child.exit.code !== null
+      && child.exit.code !== 0
+      && child.exit.code !== EXIT_ALREADY_SERVING
+    ) {
+      return {
+        kind: 'unavailable',
+        failure: 'daemon_start_failed',
+        message: `relayflowd exited ${child.exit.code} during startup.${logTail(logPath, deps)}`,
+      };
+    }
+
+    const state = await checkDaemon(dataDir, deps);
+    if (state.kind === 'attached' || state.kind === 'incompatible') return state;
+
+    if (deps.now() >= deadline) {
+      return {
+        kind: 'unavailable',
+        failure: 'daemon_start_timeout',
+        message: `relayflowd did not start serving "${socketPathFor(dataDir)}" within ${timeoutMs}ms.`
+          + logTail(logPath, deps),
+      };
+    }
+    await deps.sleep(START_POLL_INTERVAL_MS);
+  }
+}
+
+function logTail(logPath: string, deps: DaemonLifecycleDeps): string {
+  const tail = deps.readTail(logPath, LOG_TAIL_BYTES).trim();
+  return tail.length === 0 ? ` See "${logPath}".` : ` Last output in "${logPath}":\n${tail}`;
+}

package/src/failure-kinds.ts

@@ -52,18 +52,42 @@ export const PREFLIGHT_WARNING_KINDS = [
   'vacuous_gate',
 ] as const;
 
-/** Closed outcome taxonomy owned by the `flows run` / `flows resume` surface. */
+/**
+ * Closed outcome taxonomy owned by the `flows run` / `flows resume` surface.
+ *
+ * The four daemon-lifecycle kinds after `daemon_unreachable` are the
+ * attach-or-spawn refusals from kernel/DAEMON-LIFECYCLE.md §3. They split what
+ * used to be one message: `daemon_unreachable` now means only "nothing is
+ * serving and this invocation was told not to start one" (`--no-spawn`), while
+ * a spawn that was attempted and did not produce a serving daemon names which
+ * step failed. All of them are still exit 2 — refused before a journal write.
+ */
 export const RUN_FAILURE_KINDS = [
   'daemon_unreachable',
+  'daemon_protocol_mismatch',
+  'daemon_start_failed',
+  'daemon_start_timeout',
+  'relayflowd_not_found',
   'protocol_error',
   'run_parked',
   'run_unavailable',
 ] as const;
 
+/**
+ * Non-refusing outcomes of the attach step. `connection_file_stale` is
+ * DAEMON-LIFECYCLE.md §2 row 2: the socket answered while `connection.json`
+ * described a process that is gone. The socket is the authority, so this
+ * attaches — but it says so rather than passing in silence.
+ */
+export const RUN_WARNING_KINDS = [
+  'connection_file_stale',
+] as const;
+
 export type PreflightFailureKind = (typeof PREFLIGHT_FAILURE_KINDS)[number];
 export type CheckFailureKind = (typeof CHECK_FAILURE_KINDS)[number];
 export type PreflightWarningKind = (typeof PREFLIGHT_WARNING_KINDS)[number];
 export type RunFailureKind = (typeof RUN_FAILURE_KINDS)[number];
+export type RunWarningKind = (typeof RUN_WARNING_KINDS)[number];
 
 const CHECK_FAILURE_KIND_SET: ReadonlySet<string> = new Set(CHECK_FAILURE_KINDS);
 const RUN_FAILURE_KIND_SET: ReadonlySet<string> = new Set(RUN_FAILURE_KINDS);

package/src/index.ts

@@ -7,6 +7,8 @@ export type {
   AgentSurfaces,
   BaseStepSpec,
   BudgetSpec,
+  MemorySpec,
+  KernelMemorySpec,
   DeterministicStepSpec,
   ExitCodeGate,
   FlowSpec,
@@ -33,6 +35,8 @@ export type {
   StreamSurface,
   StepSpec,
   StepType,
+  PlacementRequirements,
+  KernelPlacementRequirements,
   TriggerSpec,
   VerificationGateType,
   VerificationSpec,
@@ -116,6 +120,8 @@ export type {
   StepCompleteParams,
   StepCompleteResult,
   StepDispatchEvent,
+  RoutingDecision,
+  MemoryInjectedPayload,
   StepHeartbeatParams,
   StepHeartbeatResult,
   StreamAppendParams,

package/src/journal-client.ts

@@ -27,6 +27,17 @@ import type { KernelRunSpec, StepType } from './spec.js';
 export interface JournalClientOptions {
   /** Override the timeout for bounded protocol requests (ms). Default 30000. */
   requestTimeoutMs?: number;
+  /**
+   * Bound on `connect()` (ms). Default 2000.
+   *
+   * `connect()` used to have no timer at all, which was survivable while the
+   * only caller was a command that had already decided a daemon was there.
+   * `daemon-lifecycle.ts` probes the socket before every command, and a
+   * listener that accepts but never answers would otherwise hold the CLI for
+   * the 30s request default before it could decide to spawn
+   * (kernel/DAEMON-LIFECYCLE.md §4).
+   */
+  connectTimeoutMs?: number;
 }
 
 interface Pending {
@@ -51,6 +62,7 @@ export class JournalClient extends EventEmitter {
   private buffer = '';
   private readonly pending = new Map<string, Pending>();
   private readonly requestTimeoutMs: number;
+  private readonly connectTimeoutMs: number;
 
   constructor(
     private readonly socketPath: string,
@@ -58,6 +70,7 @@ export class JournalClient extends EventEmitter {
   ) {
     super();
     this.requestTimeoutMs = options.requestTimeoutMs ?? 30_000;
+    this.connectTimeoutMs = options.connectTimeoutMs ?? 2_000;
   }
 
   /** Open the unix socket connection. Rejects on connect failure (fail-closed). */
@@ -65,13 +78,21 @@ export class JournalClient extends EventEmitter {
     return new Promise((resolve, reject) => {
       if (this.socket) return resolve();
       const socket = createConnection({ path: this.socketPath });
+      const timer = setTimeout(() => {
+        socket.removeAllListeners();
+        socket.destroy();
+        this.failAll(new Error(`journal client: connect timed out after ${this.connectTimeoutMs}ms`));
+        reject(new Error(`journal client: connect timed out after ${this.connectTimeoutMs}ms`));
+      }, this.connectTimeoutMs);
       const onError = (err: Error): void => {
+        clearTimeout(timer);
         socket.removeAllListeners();
         this.failAll(err);
         reject(new Error(`journal client: connect failed: ${err.message}`));
       };
       socket.once('error', onError);
       socket.once('connect', () => {
+        clearTimeout(timer);
         socket.removeListener('error', onError);
         socket.on('error', (err) => this.failAll(err));
         socket.on('data', (chunk) => this.onData(chunk));

package/src/protocol.ts

@@ -9,7 +9,7 @@
 //
 // This module is the typed wire surface; `journal-client.ts` implements it.
 
-import type { KernelRunSpec, StepType } from './spec.js';
+import type { KernelRunSpec, KernelMemorySpec, StepType } from './spec.js';
 
 /** Stamped per segment; readers read every past version, writers write newest. */
 export const PROTOCOL_VERSION = 0 as const;
@@ -164,7 +164,25 @@ export interface WakeContext {
 }
 
 /** Server then pushes `step.dispatch` events to the attached worker. */
+export interface MemoryInjectedPayload {
+  request: KernelMemorySpec;
+  pack: unknown;
+  budget: { tokens_in: number; tokens_out: number; dollars: string };
+  provider: string;
+}
+
+export interface RoutingDecision {
+  profile: string;
+  provider: string;
+  fallbacks_attempted: string[];
+  workspace?: string;
+}
+
 export interface StepDispatchEvent {
+  /** Durable choice; optional only for older kernel protocol compatibility. */
+  routing?: RoutingDecision;
+  /** Already journaled and charged; completion usage excludes this cost. */
+  memory?: MemoryInjectedPayload;
   run_id: string;
   step_id: string;
   attempt: number;

package/src/relayflowd-path.ts

@@ -0,0 +1,190 @@
+// Resolving the `relayflowd` binary (kernel/DAEMON-LIFECYCLE.md §3.1).
+//
+// Never PATH alone. A version manager (nvm, volta, asdf, mise) can launch Node
+// with a minimal PATH, and that is exactly the case where a `which` lookup
+// fails to see the binary the installer placed next to its own launcher. The
+// multi-anchor order below is ported from ../relay's
+// packages/harness-driver/src/broker-path.ts for that reason.
+
+import { createRequire } from 'node:module';
+import { accessSync, constants, existsSync, realpathSync, statSync } from 'node:fs';
+import { spawnSync } from 'node:child_process';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+/** How far up from cwd a source checkout is searched for `kernel/Cargo.toml`. */
+const SOURCE_CHECKOUT_MAX_DEPTH = 8;
+
+/** Refusal from {@link resolveRelayflowdBinary}; carries every anchor tried. */
+export class RelayflowdNotFoundError extends Error {
+  readonly attempts: readonly string[];
+
+  constructor(message: string, attempts: readonly string[]) {
+    super(message);
+    this.name = 'RelayflowdNotFoundError';
+    this.attempts = attempts;
+  }
+}
+
+/** Injectable seams. Unit tests reach no real filesystem and spawn nothing. */
+export interface RelayflowdPathDeps {
+  env: NodeJS.ProcessEnv;
+  /** `process.argv[1]` — the running `flows` entrypoint, possibly a symlink. */
+  entrypoint: string | undefined;
+  cwd: string;
+  /** This module's own directory, the third `createRequire` anchor. */
+  moduleDir: string;
+  platform: string;
+  arch: string;
+  isExecutable(path: string): boolean;
+  exists(path: string): boolean;
+  realpath(path: string): string;
+  /** `require.resolve(specifier)` from `anchor`, or null when unresolvable. */
+  resolveFrom(specifier: string, anchor: string): string | null;
+  /** `which`/`where` lookup, or null. */
+  which(command: string): string | null;
+}
+
+export const defaultRelayflowdPathDeps: RelayflowdPathDeps = {
+  env: process.env,
+  entrypoint: process.argv[1],
+  cwd: process.cwd(),
+  moduleDir: dirname(fileURLToPath(import.meta.url)),
+  platform: process.platform,
+  arch: process.arch,
+  isExecutable(path) {
+    try {
+      accessSync(path, constants.X_OK);
+      return statSync(path).isFile();
+    } catch {
+      return false;
+    }
+  },
+  exists: (path) => existsSync(path),
+  realpath(path) {
+    try {
+      return realpathSync(path);
+    } catch {
+      return path;
+    }
+  },
+  resolveFrom(specifier, anchor) {
+    try {
+      return createRequire(anchor).resolve(specifier);
+    } catch {
+      return null;
+    }
+  },
+  which(command) {
+    const finder = process.platform === 'win32' ? 'where' : 'which';
+    const found = spawnSync(finder, [command], { encoding: 'utf8' });
+    if (found.status !== 0 || typeof found.stdout !== 'string') return null;
+    const first = found.stdout.split('\n')[0]?.trim();
+    return first === undefined || first.length === 0 ? null : first;
+  },
+};
+
+/**
+ * The published runtime package for this host, e.g.
+ * `@relayflows/runtime-linux-x64` (see packages/runtime-linux-x64).
+ */
+export function runtimePackageName(platform: string, arch: string): string {
+  return `@relayflows/runtime-${platform}-${arch}`;
+}
+
+/**
+ * Locate `relayflowd`, or refuse.
+ *
+ * Order is §3.1's, and the first anchor is a hard stop rather than a
+ * preference: an operator who exported `RELAYFLOWD_BIN` meant it, so a value
+ * that is not executable refuses instead of quietly falling through to PATH.
+ * Silent fallback is what AGENTS.md rule 4 forbids.
+ */
+export function resolveRelayflowdBinary(
+  deps: RelayflowdPathDeps = defaultRelayflowdPathDeps,
+): string {
+  const attempts: string[] = [];
+
+  const override = deps.env['RELAYFLOWD_BIN'];
+  if (override !== undefined && override.length > 0) {
+    if (deps.isExecutable(override)) return override;
+    throw new RelayflowdNotFoundError(
+      `RELAYFLOWD_BIN is set to "${override}", which is not an executable file. `
+        + 'Point it at a relayflowd binary or unset it; it is not ignored.',
+      [`RELAYFLOWD_BIN=${override}`],
+    );
+  }
+
+  for (const candidate of [
+    () => siblingOfEntrypoint(deps),
+    () => runtimePackageBinary(deps),
+    () => sourceCheckoutBinary(deps),
+    () => deps.which('relayflowd'),
+  ]) {
+    const found = candidate();
+    if (found === null) continue;
+    attempts.push(found);
+    if (deps.isExecutable(found)) return found;
+  }
+
+  const runtime = runtimePackageName(deps.platform, deps.arch);
+  throw new RelayflowdNotFoundError(
+    `No relayflowd binary could be found. Install the runtime package for this host `
+      + `(${runtime}), or set RELAYFLOWD_BIN to a relayflowd executable.`
+      + (attempts.length === 0 ? '' : ` Tried: ${attempts.join(', ')}.`),
+    attempts,
+  );
+}
+
+/**
+ * The published layout: `bin/flows` and `bin/relayflowd` side by side.
+ * `realpath` matters — a package-manager launcher exposes the entrypoint as a
+ * symlink whose target sits in the real install tree, and the sibling is next
+ * to the target, not next to the link.
+ */
+function siblingOfEntrypoint(deps: RelayflowdPathDeps): string | null {
+  if (deps.entrypoint === undefined || deps.entrypoint.length === 0) return null;
+  return join(dirname(deps.realpath(deps.entrypoint)), 'relayflowd');
+}
+
+/**
+ * The optional-dependency package, tried from several `createRequire` anchors.
+ * Several because a globally installed `flows` resolving a per-project optional
+ * dependency sits outside the consumer's `node_modules` — broker-path.ts:84-106
+ * verbatim in its reasoning.
+ */
+function runtimePackageBinary(deps: RelayflowdPathDeps): string | null {
+  const specifier = `${runtimePackageName(deps.platform, deps.arch)}/package.json`;
+  const anchors = [
+    deps.moduleDir.endsWith('/') ? deps.moduleDir : `${deps.moduleDir}/`,
+    ...(deps.entrypoint === undefined ? [] : [deps.entrypoint]),
+    join(deps.cwd, 'package.json'),
+  ];
+  for (const anchor of anchors) {
+    const manifest = deps.resolveFrom(specifier, anchor);
+    if (manifest === null) continue;
+    return join(dirname(manifest), 'bin', 'relayflowd');
+  }
+  return null;
+}
+
+/**
+ * A source checkout: the nearest ancestor of cwd holding `kernel/Cargo.toml`,
+ * then release before debug. Bounded, so a deep cwd cannot walk to `/`.
+ */
+function sourceCheckoutBinary(deps: RelayflowdPathDeps): string | null {
+  let directory = resolve(deps.cwd);
+  for (let depth = 0; depth < SOURCE_CHECKOUT_MAX_DEPTH; depth += 1) {
+    if (deps.exists(join(directory, 'kernel', 'Cargo.toml'))) {
+      for (const profile of ['release', 'debug']) {
+        const candidate = join(directory, 'kernel', 'target', profile, 'relayflowd');
+        if (deps.isExecutable(candidate)) return candidate;
+      }
+      return null;
+    }
+    const parent = dirname(directory);
+    if (parent === directory) return null;
+    directory = parent;
+  }
+  return null;
+}

package/src/spec.ts

@@ -48,7 +48,7 @@ export type OutputVerificationSpec = OutputContainsGate | JsonSchemaGate;
 
 /**
  * Agent-step recovery modes (RFC Appendix A rule 4). Default is `reset`.
- * `deterministic` / `llm` steps have no workspace, so these do not apply.
+ * These recovery modes apply to agent steps; deterministic steps retry their commands.
  */
 export type RecoveryMode = 'reset' | 'inspect' | 'manual';
 
@@ -94,8 +94,38 @@ export interface BudgetSpec {
   maxDollars?: string;
 }
 
+/** Slice 1 records a fixed pack; retrieval is supplied by a future provider. */
+export interface MemorySpec {
+  scope: 'script' | 'agent';
+  query: string;
+  budget: BudgetSpec;
+}
+
+export interface KernelMemorySpec {
+  scope: 'script' | 'agent';
+  query: string;
+  budget: KernelBudgetSpec;
+}
+
+/** Capability needs, never provider names or source revisions. */
+export interface PlacementRequirements {
+  execution?: 'batch' | 'interactive';
+  /** Share the run tree; defaults true for deterministic steps declaring requirements. */
+  workspace?: boolean;
+  /** True requests connectivity; false does not impose a network deny policy. */
+  network?: boolean;
+  expectedDurationMs?: number;
+  preference?: 'cost' | 'latency' | 'reliability' | 'balanced';
+}
+
+export interface KernelPlacementRequirements extends Omit<PlacementRequirements, 'expectedDurationMs'> {
+  expected_duration_ms?: number;
+}
+
 /** Fields shared by every step on the ladder. */
 export interface BaseStepSpec {
+  requirements?: PlacementRequirements;
+  memory?: MemorySpec;
   /** Stable step identity; journaled as `step_id` and hashed into the idempotency key. */
   id: string;
   type: StepType;
@@ -108,7 +138,7 @@ export interface BaseStepSpec {
 /**
  * Rung 1 — a pure script. Executed by the `relayflowd` binary: spawn command,
  * capture stdout/exit code. Output = `{exit_code, stdout_tail}`. Gate-1
- * deterministic steps are pure (no pins).
+ * deterministic steps with placement requirements pin their worktree base commit.
  */
 export interface DeterministicStepSpec extends BaseStepSpec {
   type: 'deterministic';
@@ -272,6 +302,8 @@ export interface KernelVerificationSpec {
 }
 
 export interface KernelStepCommon {
+  requirements?: KernelPlacementRequirements;
+  memory?: KernelMemorySpec;
   id: string;
   depends_on: string[];
   max_iterations: number;

package/src/step-fields.ts

@@ -22,6 +22,8 @@ export const STEP_COMMON_FIELDS = [
   'dependsOn',
   'verification',
   'maxIterations',
+  'memory',
+  'requirements',
 ] as const;
 
 /**