@h-rig/runtime 0.0.6-alpha.0

package/dist/src/control-plane/validators/shared.js

@@ -0,0 +1,683 @@
+// @bun
+// packages/runtime/src/control-plane/validators/shared.ts
+import { existsSync as existsSync5, statSync as statSync2 } from "fs";
+import { resolve as resolve5 } from "path";
+
+// packages/runtime/src/build-time-config.ts
+function normalizeBuildConfig(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return {};
+  }
+  return Object.fromEntries(Object.entries(value).filter((entry) => typeof entry[1] === "string"));
+}
+function readBuildConfig() {
+  if (typeof __RIG_BUILD_CONFIG__ !== "undefined") {
+    return normalizeBuildConfig(__RIG_BUILD_CONFIG__);
+  }
+  const raw = process.env.RIG_BUILD_CONFIG_JSON?.trim();
+  if (!raw) {
+    return {};
+  }
+  try {
+    return normalizeBuildConfig(JSON.parse(raw));
+  } catch {
+    return {};
+  }
+}
+
+// packages/runtime/src/control-plane/runtime/context.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { dirname, resolve } from "path";
+var RUNTIME_CONTEXT_ENV = "RIG_RUNTIME_CONTEXT_FILE";
+var runtimeContextStringFields = [
+  "runtimeId",
+  "taskId",
+  "role",
+  "workspaceDir",
+  "stateDir",
+  "logsDir",
+  "sessionDir",
+  "sessionFile",
+  "policyFile",
+  "binDir",
+  "createdAt"
+];
+var runtimeContextArrayFields = ["scopes", "validation"];
+var runtimeContextOptionalStringFields = [
+  "artifactRoot",
+  "hostProjectRoot",
+  "monorepoMainRoot",
+  "monorepoBaseRef",
+  "monorepoBaseCommit"
+];
+function loadRuntimeContext(path) {
+  const absPath = resolve(path);
+  if (!existsSync(absPath)) {
+    throw new Error(`RuntimeTaskContext file not found: ${absPath}`);
+  }
+  let raw;
+  try {
+    raw = JSON.parse(readFileSync(absPath, "utf8"));
+  } catch (err) {
+    throw new Error(`Failed to parse RuntimeTaskContext at ${absPath}: ${String(err)}`);
+  }
+  if (typeof raw !== "object" || raw === null) {
+    throw new Error(`RuntimeTaskContext at ${absPath} is not an object`);
+  }
+  const obj = raw;
+  for (const field of runtimeContextStringFields) {
+    if (typeof obj[field] !== "string" || obj[field].length === 0) {
+      throw new Error(`RuntimeTaskContext field "${field}" must be a non-empty string (at ${absPath})`);
+    }
+  }
+  for (const field of runtimeContextArrayFields) {
+    if (!Array.isArray(obj[field])) {
+      throw new Error(`RuntimeTaskContext field "${field}" must be an array (at ${absPath})`);
+    }
+    if (!obj[field].every((entry) => typeof entry === "string")) {
+      throw new Error(`RuntimeTaskContext field "${field}" must be a string[] (at ${absPath})`);
+    }
+  }
+  for (const field of runtimeContextOptionalStringFields) {
+    if (field in obj && obj[field] !== undefined && typeof obj[field] !== "string") {
+      throw new Error(`RuntimeTaskContext field "${field}" must be a string when present (at ${absPath})`);
+    }
+  }
+  if (obj.browser !== undefined) {
+    if (typeof obj.browser !== "object" || obj.browser === null || Array.isArray(obj.browser)) {
+      throw new Error(`RuntimeTaskContext field "browser" must be an object when present (at ${absPath})`);
+    }
+    const browser = obj.browser;
+    for (const field of [
+      "preset",
+      "mode",
+      "stateDir",
+      "defaultProfile",
+      "effectiveProfile",
+      "defaultAttachUrl",
+      "effectiveAttachUrl",
+      "launchHelper",
+      "checkHelper",
+      "attachInfoHelper",
+      "e2eHelper",
+      "resetProfileHelper"
+    ]) {
+      if (typeof browser[field] !== "string" || browser[field].length === 0) {
+        throw new Error(`RuntimeTaskContext field "browser.${field}" must be a non-empty string (at ${absPath})`);
+      }
+    }
+    for (const field of ["devCommand", "launchCommand", "checkCommand", "e2eCommand"]) {
+      if (browser[field] !== undefined && typeof browser[field] !== "string") {
+        throw new Error(`RuntimeTaskContext field "browser.${field}" must be a string when present (at ${absPath})`);
+      }
+    }
+    if (typeof browser.required !== "boolean") {
+      throw new Error(`RuntimeTaskContext field "browser.required" must be a boolean (at ${absPath})`);
+    }
+  }
+  if (obj.memory !== undefined) {
+    if (typeof obj.memory !== "object" || obj.memory === null || Array.isArray(obj.memory)) {
+      throw new Error(`RuntimeTaskContext field "memory" must be an object when present (at ${absPath})`);
+    }
+    const memory = obj.memory;
+    for (const field of ["canonicalPath", "canonicalRef", "canonicalBaseOid", "hydratedPath"]) {
+      if (typeof memory[field] !== "string" || memory[field].length === 0) {
+        throw new Error(`RuntimeTaskContext field "memory.${field}" must be a non-empty string (at ${absPath})`);
+      }
+    }
+    if (typeof memory.createdFresh !== "boolean") {
+      throw new Error(`RuntimeTaskContext field "memory.createdFresh" must be a boolean (at ${absPath})`);
+    }
+    if (typeof memory.retrieval !== "object" || memory.retrieval === null || Array.isArray(memory.retrieval)) {
+      throw new Error(`RuntimeTaskContext field "memory.retrieval" must be an object (at ${absPath})`);
+    }
+    const retrieval = memory.retrieval;
+    for (const field of ["topK", "lexicalWeight", "vectorWeight", "recencyWeight", "confidenceWeight"]) {
+      if (typeof retrieval[field] !== "number" || Number.isNaN(retrieval[field])) {
+        throw new Error(`RuntimeTaskContext field "memory.retrieval.${field}" must be a number (at ${absPath})`);
+      }
+    }
+  }
+  if (obj.initialDirtyFiles !== undefined) {
+    if (typeof obj.initialDirtyFiles !== "object" || obj.initialDirtyFiles === null || Array.isArray(obj.initialDirtyFiles)) {
+      throw new Error(`RuntimeTaskContext field "initialDirtyFiles" must be an object when present (at ${absPath})`);
+    }
+    const dirtyFiles = obj.initialDirtyFiles;
+    for (const key of ["project", "monorepo"]) {
+      if (dirtyFiles[key] === undefined) {
+        continue;
+      }
+      if (!Array.isArray(dirtyFiles[key]) || !dirtyFiles[key].every((entry) => typeof entry === "string")) {
+        throw new Error(`RuntimeTaskContext field "initialDirtyFiles.${key}" must be a string[] when present (at ${absPath})`);
+      }
+    }
+  }
+  if (obj.initialHeadCommits !== undefined) {
+    if (typeof obj.initialHeadCommits !== "object" || obj.initialHeadCommits === null || Array.isArray(obj.initialHeadCommits)) {
+      throw new Error(`RuntimeTaskContext field "initialHeadCommits" must be an object when present (at ${absPath})`);
+    }
+    const headCommits = obj.initialHeadCommits;
+    for (const key of ["project", "monorepo"]) {
+      if (headCommits[key] === undefined) {
+        continue;
+      }
+      if (typeof headCommits[key] !== "string") {
+        throw new Error(`RuntimeTaskContext field "initialHeadCommits.${key}" must be a string when present (at ${absPath})`);
+      }
+    }
+  }
+  return obj;
+}
+function loadRuntimeContextFromEnv(env = process.env) {
+  const contextFile = env[RUNTIME_CONTEXT_ENV];
+  if (contextFile) {
+    return loadRuntimeContext(contextFile);
+  }
+  const inferred = findRuntimeContextFile(process.cwd());
+  if (!inferred) {
+    return null;
+  }
+  return loadRuntimeContext(inferred);
+}
+function findRuntimeContextFile(startPath) {
+  let current = resolve(startPath);
+  while (true) {
+    const candidate = resolve(current, "runtime-context.json");
+    if (existsSync(candidate) && isAgentRuntimeContextPath(candidate)) {
+      return candidate;
+    }
+    const parent = dirname(current);
+    if (parent === current) {
+      return "";
+    }
+    current = parent;
+  }
+}
+function isAgentRuntimeContextPath(path) {
+  const normalized = path.replace(/\\/g, "/");
+  return /\/\.rig\/runtime-context\.json$/.test(normalized);
+}
+
+// packages/runtime/src/control-plane/runtime/runtime-paths.ts
+import { existsSync as existsSync3, readdirSync, realpathSync } from "fs";
+import { resolve as resolve3 } from "path";
+
+// packages/runtime/src/layout.ts
+import { existsSync as existsSync2 } from "fs";
+import { basename, dirname as dirname2, resolve as resolve2 } from "path";
+function resolveMonorepoRoot(projectRoot) {
+  const normalizedProjectRoot = resolve2(projectRoot);
+  const explicit = process.env.MONOREPO_ROOT?.trim();
+  if (explicit) {
+    const explicitRoot = resolve2(explicit);
+    const explicitParent = dirname2(explicitRoot);
+    if (basename(explicitParent) === ".worktrees") {
+      const owner = dirname2(explicitParent);
+      const ownerHasGit = existsSync2(resolve2(owner, ".git"));
+      const ownerHasTaskConfig = existsSync2(resolve2(owner, ".rig", "task-config.json"));
+      const ownerHasRigConfig = existsSync2(resolve2(owner, "rig.config.ts"));
+      if (ownerHasGit && (ownerHasTaskConfig || ownerHasRigConfig)) {
+        return owner;
+      }
+      throw new Error(`MONOREPO_ROOT points to worktree ${explicitRoot}, but the owner checkout is incomplete at ${owner}.`);
+    }
+    if (!existsSync2(resolve2(explicitRoot, ".git"))) {
+      throw new Error(`MONOREPO_ROOT points to ${explicitRoot}, but no git checkout was found there.`);
+    }
+    const hasTaskConfig = existsSync2(resolve2(explicitRoot, ".rig", "task-config.json"));
+    const hasRigConfig = existsSync2(resolve2(explicitRoot, "rig.config.ts"));
+    if (!hasTaskConfig && !hasRigConfig) {
+      throw new Error(`MONOREPO_ROOT points to ${explicitRoot}, but neither .rig/task-config.json nor rig.config.ts exists there.`);
+    }
+    return explicitRoot;
+  }
+  const projectParent = dirname2(normalizedProjectRoot);
+  if (basename(projectParent) === ".worktrees") {
+    const worktreeOwner = dirname2(projectParent);
+    const ownerHasGit = existsSync2(resolve2(worktreeOwner, ".git"));
+    const ownerHasTaskConfig = existsSync2(resolve2(worktreeOwner, ".rig", "task-config.json"));
+    const ownerHasRigConfig = existsSync2(resolve2(worktreeOwner, "rig.config.ts"));
+    if (ownerHasGit && (ownerHasTaskConfig || ownerHasRigConfig)) {
+      return worktreeOwner;
+    }
+  }
+  return normalizedProjectRoot;
+}
+// packages/runtime/src/control-plane/runtime/runtime-paths.ts
+function resolveBunBinaryPath() {
+  const explicit = normalizeExecutablePath(process.env.RIG_BUN_PATH?.trim());
+  if (explicit) {
+    return explicit;
+  }
+  const pathBun = normalizeExecutablePath(Bun.which("bun")?.trim());
+  if (pathBun && !looksLikeRuntimeGateway(pathBun)) {
+    return pathBun;
+  }
+  const home = process.env.HOME?.trim();
+  const fallbackCandidates = [
+    home ? resolve3(home, ".bun/bin/bun") : "",
+    "/opt/homebrew/bin/bun",
+    "/usr/local/bin/bun",
+    "/usr/bin/bun"
+  ];
+  for (const candidate of fallbackCandidates) {
+    const normalized = normalizeExecutablePath(candidate);
+    if (normalized) {
+      return normalized;
+    }
+  }
+  const execPath = normalizeExecutablePath(process.execPath?.trim());
+  if (execPath && !looksLikeRuntimeGateway(execPath)) {
+    return execPath;
+  }
+  throw new Error("bun not found in PATH");
+}
+function normalizeExecutablePath(candidate) {
+  if (!candidate) {
+    return "";
+  }
+  const normalized = resolve3(candidate);
+  if (!existsSync3(normalized)) {
+    return "";
+  }
+  try {
+    return realpathSync(normalized);
+  } catch {
+    return normalized;
+  }
+}
+function looksLikeRuntimeGateway(candidate) {
+  const normalized = resolve3(candidate).replace(/\\/g, "/");
+  return normalized.includes("/.rig/bin/") || normalized.endsWith("/rig-shell") || normalized.endsWith("/rig-agent");
+}
+
+// packages/runtime/src/control-plane/native/runtime-native.ts
+import { dlopen, ptr, suffix, toBuffer } from "bun:ffi";
+import { copyFileSync, existsSync as existsSync4, mkdirSync as mkdirSync2, renameSync, rmSync, statSync } from "fs";
+import { tmpdir } from "os";
+import { dirname as dirname3, resolve as resolve4 } from "path";
+var sharedNativeRuntimeOutputDir = resolve4(tmpdir(), "rig-native");
+var sharedNativeRuntimeOutputPath = resolve4(sharedNativeRuntimeOutputDir, `runtime-native-${process.platform}-${process.arch}.${suffix}`);
+var colocatedNativeRuntimeFileName = `runtime-native.${suffix}`;
+var nativeRuntimeLibrary = await loadNativeRuntimeLibrary();
+async function ensureNativeRuntimeLibraryPath(outputPath = sharedNativeRuntimeOutputPath, options = {}) {
+  if (await buildNativeRuntimeLibrary(outputPath, options)) {
+    return outputPath;
+  }
+  return !options.force && existsSync4(outputPath) ? outputPath : null;
+}
+async function loadNativeRuntimeLibrary() {
+  if (process.env.RIG_DISABLE_ZIG_NATIVE === "1") {
+    return null;
+  }
+  for (const candidate of nativeRuntimeLibraryCandidates()) {
+    if (!candidate || !existsSync4(candidate)) {
+      continue;
+    }
+    const loaded = tryDlopenNativeRuntimeLibrary(candidate);
+    if (loaded) {
+      return loaded;
+    }
+  }
+  const builtLibraryPath = await ensureNativeRuntimeLibraryPath(sharedNativeRuntimeOutputPath, { force: true });
+  if (!builtLibraryPath) {
+    return null;
+  }
+  return tryDlopenNativeRuntimeLibrary(builtLibraryPath);
+}
+function nativePackageLibraryCandidates(fromDir, names) {
+  const candidates = [];
+  let cursor = resolve4(fromDir);
+  for (let index = 0;index < 8; index += 1) {
+    for (const name of names) {
+      candidates.push(resolve4(cursor, "native", `${process.platform}-${process.arch}`, name), resolve4(cursor, "native", `${process.platform}-${process.arch}`, "lib", name), resolve4(cursor, "native", name), resolve4(cursor, "native", "lib", name));
+    }
+    const parent = dirname3(cursor);
+    if (parent === cursor)
+      break;
+    cursor = parent;
+  }
+  return candidates;
+}
+function nativeRuntimeLibraryCandidates() {
+  const explicit = process.env.RIG_NATIVE_RUNTIME_LIB?.trim() || "";
+  const execDir = process.execPath?.trim() ? dirname3(process.execPath.trim()) : "";
+  const platformSpecific = `runtime-native-${process.platform}-${process.arch}.${suffix}`;
+  return [...new Set([
+    explicit,
+    ...nativePackageLibraryCandidates(import.meta.dir, [colocatedNativeRuntimeFileName, platformSpecific]),
+    execDir ? resolve4(execDir, colocatedNativeRuntimeFileName) : "",
+    execDir ? resolve4(execDir, platformSpecific) : "",
+    execDir ? resolve4(execDir, "..", colocatedNativeRuntimeFileName) : "",
+    execDir ? resolve4(execDir, "..", platformSpecific) : "",
+    execDir ? resolve4(execDir, "lib", colocatedNativeRuntimeFileName) : "",
+    execDir ? resolve4(execDir, "..", "lib", colocatedNativeRuntimeFileName) : "",
+    sharedNativeRuntimeOutputPath
+  ].filter(Boolean))];
+}
+function resolveNativeRuntimeSourcePath() {
+  const explicit = process.env.RIG_NATIVE_RUNTIME_SOURCE?.trim();
+  if (explicit && existsSync4(explicit)) {
+    return explicit;
+  }
+  const bundled = resolve4(import.meta.dir, "../../../native/snapshot.zig");
+  return existsSync4(bundled) ? bundled : null;
+}
+async function buildNativeRuntimeLibrary(outputPath, options = {}) {
+  if (process.env.RIG_DISABLE_ZIG_NATIVE === "1") {
+    return false;
+  }
+  const zigBinary = Bun.which("zig");
+  const sourcePath = resolveNativeRuntimeSourcePath();
+  if (!zigBinary || !sourcePath) {
+    return false;
+  }
+  const tempOutputPath = `${outputPath}.${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2)}.tmp`;
+  try {
+    mkdirSync2(dirname3(outputPath), { recursive: true });
+    const needsBuild = options.force === true || !existsSync4(outputPath) || statSync(sourcePath).mtimeMs > statSync(outputPath).mtimeMs;
+    if (!needsBuild) {
+      return true;
+    }
+    const build = Bun.spawn([
+      zigBinary,
+      "build-lib",
+      sourcePath,
+      "-dynamic",
+      "-O",
+      "ReleaseFast",
+      `-femit-bin=${tempOutputPath}`
+    ], {
+      cwd: import.meta.dir,
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    const exitCode = await build.exited;
+    if (exitCode !== 0 || !existsSync4(tempOutputPath)) {
+      rmSync(tempOutputPath, { force: true });
+      return false;
+    }
+    renameSync(tempOutputPath, outputPath);
+    return true;
+  } catch {
+    rmSync(tempOutputPath, { force: true });
+    return false;
+  }
+}
+function tryDlopenNativeRuntimeLibrary(outputPath) {
+  try {
+    return dlopen(outputPath, {
+      rig_scope_match: {
+        args: ["ptr", "ptr"],
+        returns: "u8"
+      },
+      snapshot_capture: {
+        args: ["ptr", "u64", "ptr", "u64"],
+        returns: "ptr"
+      },
+      snapshot_delta: {
+        args: ["ptr", "ptr"],
+        returns: "ptr"
+      },
+      snapshot_store_delta: {
+        args: ["ptr", "ptr", "ptr", "u64", "ptr", "u64", "ptr", "u64", "ptr", "u64"],
+        returns: "ptr"
+      },
+      snapshot_inspect_delta: {
+        args: ["ptr", "u64"],
+        returns: "ptr"
+      },
+      snapshot_apply_delta: {
+        args: ["ptr", "u64", "ptr", "u64"],
+        returns: "ptr"
+      },
+      snapshot_release: {
+        args: ["ptr"],
+        returns: "void"
+      },
+      runtime_hash_file: {
+        args: ["ptr", "u64"],
+        returns: "ptr"
+      },
+      runtime_hash_tree: {
+        args: ["ptr", "u64"],
+        returns: "ptr"
+      },
+      runtime_prepare_paths: {
+        args: ["ptr", "u64", "ptr", "u64", "ptr", "u64", "ptr", "u64", "ptr", "u64"],
+        returns: "ptr"
+      },
+      runtime_link_dependency_layer: {
+        args: ["ptr", "u64", "ptr", "u64"],
+        returns: "ptr"
+      },
+      runtime_scan_worktrees: {
+        args: ["ptr", "u64"],
+        returns: "ptr"
+      }
+    });
+  } catch {
+    return null;
+  }
+}
+
+// packages/runtime/src/control-plane/native/utils.ts
+function resolveMonorepoRoot2(projectRoot) {
+  return resolveMonorepoRoot(projectRoot);
+}
+var scopeRegexCache = new Map;
+
+// packages/runtime/src/control-plane/validators/shared.ts
+import { pass, fail, error, Checker } from "@rig/validator-kit";
+import {
+  findFirstFile,
+  readFileSafe,
+  requireFile,
+  fileContains,
+  walkDir,
+  listSubdirs,
+  countTsFiles,
+  countTestFiles,
+  findFirstDir,
+  findFilesByName
+} from "@rig/validator-kit";
+import { grepFiles, grepCount, grepLines } from "@rig/validator-kit";
+import { requireMarkdownSections, requireTerms, requireJsonKeys } from "@rig/validator-kit";
+import {
+  requireFileCheck,
+  requireDirCheck,
+  requirePackageStructure,
+  checkTestsExist
+} from "@rig/validator-kit";
+var BUILD_CONFIG = readBuildConfig();
+var BAKED_BUN_PATH = BUILD_CONFIG.AGENT_BUN_PATH ?? "";
+var RUNTIME_CONTEXT = loadRuntimeContextFromEnv();
+var PROJECT_ROOT = BUILD_CONFIG.AGENT_PROJECT_ROOT ? BUILD_CONFIG.AGENT_PROJECT_ROOT : RUNTIME_CONTEXT?.hostProjectRoot ? RUNTIME_CONTEXT.hostProjectRoot : process.env.RIG_HOST_PROJECT_ROOT || process.env.PROJECT_RIG_ROOT || process.cwd();
+var TASK_ID = BUILD_CONFIG.AGENT_TASK_ID ? BUILD_CONFIG.AGENT_TASK_ID : process.env.RIG_TASK_ID || "";
+function tryResolveMonorepoRoot(projectRoot) {
+  try {
+    return resolveMonorepoRoot2(projectRoot);
+  } catch {
+    return null;
+  }
+}
+var FALLBACK_MONOREPO_ROOT = tryResolveMonorepoRoot(PROJECT_ROOT);
+var WORKSPACE = RUNTIME_CONTEXT?.workspaceDir || process.env.RIG_TASK_WORKSPACE?.trim() || process.env.MONOREPO_ROOT?.trim() || FALLBACK_MONOREPO_ROOT || PROJECT_ROOT;
+var MONOREPO_ROOT = process.env.MONOREPO_ROOT?.trim() || WORKSPACE;
+var MONOREPO_MAIN_ROOT = RUNTIME_CONTEXT?.monorepoMainRoot || process.env.MONOREPO_MAIN_ROOT?.trim() || FALLBACK_MONOREPO_ROOT || MONOREPO_ROOT;
+var HP_BACKEND = resolve5(WORKSPACE, "humoongate/humanity/hp-backend-ts");
+var MOONGATE_CORE = resolve5(WORKSPACE, "humoongate/moongate/core-app");
+var ARTIFACTS_DIR = resolve5(WORKSPACE, "artifacts");
+var TASK_CONFIG_PATH = existsSync5(resolve5(WORKSPACE, ".rig", "task-config.json")) ? resolve5(WORKSPACE, ".rig", "task-config.json") : resolve5(MONOREPO_MAIN_ROOT, ".rig", "task-config.json");
+var TS_API_TESTS_DIR = process.env.TS_API_TESTS_DIR || resolve5(WORKSPACE, "TSAPITests");
+var STATE_DIR = resolve5(WORKSPACE, ".rig", "state");
+var PACKAGES_DIR = resolve5(WORKSPACE, "packages");
+var CI_WORKFLOWS_DIR = resolve5(WORKSPACE, ".github/workflows");
+function resolveBunCli() {
+  return resolveBunCliInvocation().command;
+}
+function resolveBunCliInvocation() {
+  if (BAKED_BUN_PATH) {
+    return {
+      command: BAKED_BUN_PATH,
+      env: {}
+    };
+  }
+  if (process.env.RIG_BUN_PATH?.trim()) {
+    return {
+      command: process.env.RIG_BUN_PATH.trim(),
+      env: {}
+    };
+  }
+  try {
+    const systemBun = resolveBunBinaryPath();
+    return {
+      command: systemBun,
+      env: {}
+    };
+  } catch {}
+  if (process.execPath?.trim()) {
+    return {
+      command: process.execPath,
+      env: { BUN_BE_BUN: "1" }
+    };
+  }
+  return { command: "bun", env: {} };
+}
+function artifactDirForId(id) {
+  return resolve5(ARTIFACTS_DIR, id);
+}
+function artifactDir() {
+  return resolve5(ARTIFACTS_DIR, TASK_ID);
+}
+function requireArtifact(checker, taskId, ...files) {
+  const dir = artifactDirForId(taskId);
+  if (!existsSync5(dir) || !statSync2(dir).isDirectory()) {
+    checker.fail(`${taskId}-artifact-dir`, `artifact directory missing: ${dir}`);
+    return null;
+  }
+  checker.pass(`${taskId}-artifact-dir`);
+  for (const file of files) {
+    const full = resolve5(dir, file);
+    if (existsSync5(full)) {
+      checker.pass(`${taskId}/${file}`);
+    } else {
+      checker.fail(`${taskId}/${file}`, `required artifact file missing: ${full}`);
+    }
+  }
+  return dir;
+}
+async function runCommand(cmd, cwd) {
+  const bunCli = resolveBunCliInvocation();
+  const env = {
+    ...process.env,
+    ...bunCli.env,
+    PWD: cwd,
+    INIT_CWD: cwd
+  };
+  if (cmd[0] === "bun" || cmd[0] === "bunx") {
+    const normalized = cmd[0] === "bunx" ? [bunCli.command, "x", ...cmd.slice(1)] : [bunCli.command, ...cmd.slice(1)];
+    const proc2 = Bun.spawn(normalized, { cwd, stdout: "pipe", stderr: "pipe", env });
+    const exitCode2 = await proc2.exited;
+    return {
+      exitCode: exitCode2,
+      stdout: await new Response(proc2.stdout).text(),
+      stderr: await new Response(proc2.stderr).text()
+    };
+  }
+  const proc = Bun.spawn(cmd, { cwd, stdout: "pipe", stderr: "pipe", env });
+  const exitCode = await proc.exited;
+  const stdout = await new Response(proc.stdout).text();
+  const stderr = await new Response(proc.stderr).text();
+  return { exitCode, stdout, stderr };
+}
+function resolveTypescriptCommand(projectDir) {
+  const tsconfigPath = resolve5(projectDir, "tsconfig.json");
+  const bunCli = resolveBunCli();
+  const candidates = [
+    resolve5(projectDir, "node_modules", "typescript", "lib", "tsc.js"),
+    resolve5(projectDir, "..", "node_modules", "typescript", "lib", "tsc.js"),
+    resolve5(projectDir, "..", "..", "node_modules", "typescript", "lib", "tsc.js"),
+    resolve5(projectDir, "..", "..", "..", "node_modules", "typescript", "lib", "tsc.js")
+  ];
+  for (const candidate of candidates) {
+    if (existsSync5(candidate)) {
+      return [bunCli, candidate, "--noEmit", "--project", tsconfigPath];
+    }
+  }
+  return ["bunx", "tsc", "--noEmit", "--project", tsconfigPath];
+}
+async function checkTypescriptCompiles(checker, projectDir, checkName) {
+  if (!existsSync5(resolve5(projectDir, "tsconfig.json"))) {
+    checker.fail(checkName, "no tsconfig.json found");
+    return;
+  }
+  const command = resolveTypescriptCommand(projectDir);
+  const transientRetryDelaysMs = [250, 500, 1000, 1500];
+  let result = await runCommand(command, projectDir);
+  let combined = result.stdout + result.stderr;
+  let errorCount = combined.split(`
+`).filter((l) => l.includes("error TS")).length;
+  for (const delayMs of transientRetryDelaysMs) {
+    if (result.exitCode === 0 || errorCount > 0) {
+      break;
+    }
+    await Bun.sleep(delayMs);
+    result = await runCommand(command, projectDir);
+    combined = result.stdout + result.stderr;
+    errorCount = combined.split(`
+`).filter((l) => l.includes("error TS")).length;
+  }
+  if (result.exitCode === 0) {
+    checker.pass(checkName);
+  } else {
+    const detail = errorCount > 0 ? `${errorCount} TypeScript errors` : `TypeScript command exited ${result.exitCode} without TS diagnostics`;
+    checker.fail(checkName, detail);
+  }
+}
+export {
+  walkDir,
+  runCommand,
+  resolveBunCliInvocation,
+  resolveBunCli,
+  requireTerms,
+  requirePackageStructure,
+  requireMarkdownSections,
+  requireJsonKeys,
+  requireFileCheck,
+  requireFile,
+  requireDirCheck,
+  requireArtifact,
+  readFileSafe,
+  pass,
+  listSubdirs,
+  grepLines,
+  grepFiles,
+  grepCount,
+  findFirstFile,
+  findFirstDir,
+  findFilesByName,
+  fileContains,
+  fail,
+  error,
+  countTsFiles,
+  countTestFiles,
+  checkTypescriptCompiles,
+  checkTestsExist,
+  artifactDirForId,
+  artifactDir,
+  WORKSPACE,
+  TS_API_TESTS_DIR,
+  TASK_ID,
+  TASK_CONFIG_PATH,
+  STATE_DIR,
+  PROJECT_ROOT,
+  PACKAGES_DIR,
+  MOONGATE_CORE,
+  MONOREPO_ROOT,
+  MONOREPO_MAIN_ROOT,
+  HP_BACKEND,
+  Checker,
+  CI_WORKFLOWS_DIR,
+  ARTIFACTS_DIR
+};