@h-rig/runtime 0.0.6-alpha.34 → 0.0.6-alpha.36

package/dist/src/control-plane/native/verifier.js

@@ -1,7 +1,7 @@
 // @bun
 // packages/runtime/src/control-plane/native/verifier.ts
-import { existsSync as existsSync12, mkdirSync as mkdirSync6, writeFileSync as writeFileSync7 } from "fs";
-import { resolve as resolve14 } from "path";
+import { existsSync as existsSync14, mkdirSync as mkdirSync7, writeFileSync as writeFileSync8 } from "fs";
+import { resolve as resolve15 } from "path";
 
 // packages/runtime/src/control-plane/runtime/baked-secrets.ts
 var BAKED_RUNTIME_SECRETS = {
@@ -47,8 +47,8 @@ function resolveRuntimeSecrets(env, baked = BAKED_RUNTIME_SECRETS) {
 }
 
 // packages/runtime/src/control-plane/native/git-ops.ts
-import { existsSync as existsSync11, lstatSync, mkdirSync as mkdirSync5, readFileSync as readFileSync8, writeFileSync as writeFileSync6 } from "fs";
-import { dirname as dirname8, isAbsolute as isAbsolute2, resolve as resolve13 } from "path";
+import { existsSync as existsSync13, lstatSync, mkdirSync as mkdirSync6, readFileSync as readFileSync9, writeFileSync as writeFileSync7 } from "fs";
+import { dirname as dirname9, isAbsolute as isAbsolute2, resolve as resolve14 } from "path";
 
 // packages/runtime/src/control-plane/runtime/context.ts
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
@@ -262,6 +262,8 @@ import { basename as basename2, dirname as dirname4, resolve as resolve4 } from
 var sharedNativeToolsOutputDir = resolve4(tmpdir3(), "rig-native");
 var sharedNativeToolsOutputPath = resolve4(sharedNativeToolsOutputDir, `rig-tools-${process.platform}-${process.arch}${process.platform === "win32" ? ".exe" : ""}`);
 // packages/runtime/src/control-plane/plugin-host-context.ts
+import { existsSync as existsSync6 } from "fs";
+import { resolve as resolvePath } from "path";
 import { createPluginHost } from "@rig/core";
 import { loadConfig } from "@rig/core/load-config";
 
@@ -588,6 +590,55 @@ async function materializeSkills(projectRoot, entries) {
   return written;
 }
 
+// packages/runtime/src/control-plane/pi-settings-materializer.ts
+import { existsSync as existsSync5, mkdirSync as mkdirSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync4 } from "fs";
+import { dirname as dirname6, resolve as resolve7 } from "path";
+var SETTINGS_RELATIVE_PATH = ".pi/settings.json";
+var MANAGED_RECORD_RELATIVE_PATH = ".rig/state/pi-managed-packages.json";
+function readJson(path, fallback) {
+  if (!existsSync5(path))
+    return fallback;
+  try {
+    return JSON.parse(readFileSync4(path, "utf-8"));
+  } catch {
+    return fallback;
+  }
+}
+function packageKey(entry) {
+  if (typeof entry === "string")
+    return entry;
+  if (entry && typeof entry === "object" && typeof entry.source === "string") {
+    return entry.source;
+  }
+  return JSON.stringify(entry);
+}
+function materializePiPackages(projectRoot, declaredPackages) {
+  const settingsPath = resolve7(projectRoot, SETTINGS_RELATIVE_PATH);
+  const managedRecordPath = resolve7(projectRoot, MANAGED_RECORD_RELATIVE_PATH);
+  const settings = readJson(settingsPath, {});
+  const previouslyManaged = new Set(readJson(managedRecordPath, []));
+  const existing = Array.isArray(settings.packages) ? settings.packages : [];
+  const operatorEntries = existing.filter((entry) => !previouslyManaged.has(packageKey(entry)));
+  const operatorKeys = new Set(operatorEntries.map(packageKey));
+  const managedToAdd = declaredPackages.filter((pkg) => !operatorKeys.has(pkg));
+  const nextPackages = [...operatorEntries, ...managedToAdd];
+  if (nextPackages.length > 0 || existsSync5(settingsPath)) {
+    const nextSettings = { ...settings };
+    if (nextPackages.length > 0) {
+      nextSettings.packages = nextPackages;
+    } else {
+      delete nextSettings.packages;
+    }
+    mkdirSync4(dirname6(settingsPath), { recursive: true });
+    writeFileSync4(settingsPath, `${JSON.stringify(nextSettings, null, 2)}
+`, "utf-8");
+  }
+  mkdirSync4(dirname6(managedRecordPath), { recursive: true });
+  writeFileSync4(managedRecordPath, `${JSON.stringify(managedToAdd, null, 2)}
+`, "utf-8");
+  return { settingsPath, packages: managedToAdd };
+}
+
 // packages/runtime/src/control-plane/plugin-host-context.ts
 async function buildPluginHostContext(projectRoot) {
   let config;
@@ -635,6 +686,14 @@ async function buildPluginHostContext(projectRoot) {
   } catch (err) {
     console.warn(`[plugin-host] skill materialization failed: ${err instanceof Error ? err.message : err}`);
   }
+  try {
+    const piPackages = config.runtime?.pi?.packages ?? [];
+    if (piPackages.length > 0 || existsSync6(resolvePath(projectRoot, ".rig/state/pi-managed-packages.json"))) {
+      materializePiPackages(projectRoot, piPackages);
+    }
+  } catch (err) {
+    console.warn(`[plugin-host] Pi package materialization failed: ${err instanceof Error ? err.message : err}`);
+  }
   return {
     config,
     pluginHost,
@@ -648,12 +707,12 @@ async function buildPluginHostContext(projectRoot) {
 
 // packages/runtime/src/control-plane/tasks/source-aware-task-config-source.ts
 import { spawnSync } from "child_process";
-import { existsSync as existsSync6, readFileSync as readFileSync5, readdirSync as readdirSync2, statSync, writeFileSync as writeFileSync4 } from "fs";
-import { basename as basename3, join as join2, resolve as resolve8 } from "path";
+import { existsSync as existsSync8, readFileSync as readFileSync6, readdirSync as readdirSync2, statSync, writeFileSync as writeFileSync5 } from "fs";
+import { basename as basename3, join as join2, resolve as resolve9 } from "path";
 
 // packages/runtime/src/control-plane/tasks/legacy-task-config-source.ts
-import { existsSync as existsSync5, readFileSync as readFileSync4 } from "fs";
-import { resolve as resolve7 } from "path";
+import { existsSync as existsSync7, readFileSync as readFileSync5 } from "fs";
+import { resolve as resolve8 } from "path";
 
 // packages/runtime/src/control-plane/tasks/task-record-reader.ts
 async function findTaskById(reader, id) {
@@ -676,7 +735,7 @@ class LegacyTaskConfigReadError extends Error {
   }
 }
 function createLegacyTaskConfigRecordReader(projectRoot, options = {}) {
-  const configPath = options.configPath ?? resolve7(projectRoot, ".rig", "task-config.json");
+  const configPath = options.configPath ?? resolve8(projectRoot, ".rig", "task-config.json");
   const reader = {
     async listTasks() {
       return readLegacyTaskRecords(projectRoot, configPath);
@@ -687,8 +746,8 @@ function createLegacyTaskConfigRecordReader(projectRoot, options = {}) {
   };
   return reader;
 }
-function readLegacyTaskRecords(projectRoot, configPath = resolve7(projectRoot, ".rig", "task-config.json")) {
-  if (!existsSync5(configPath)) {
+function readLegacyTaskRecords(projectRoot, configPath = resolve8(projectRoot, ".rig", "task-config.json")) {
+  if (!existsSync7(configPath)) {
     return [];
   }
   const rawConfig = readLegacyTaskConfigJson(projectRoot, configPath);
@@ -696,7 +755,7 @@ function readLegacyTaskRecords(projectRoot, configPath = resolve7(projectRoot, "
 }
 function readLegacyTaskConfigJson(projectRoot, configPath) {
   try {
-    const parsed = JSON.parse(readFileSync4(configPath, "utf8"));
+    const parsed = JSON.parse(readFileSync5(configPath, "utf8"));
     if (isPlainRecord(parsed)) {
       return parsed;
     }
@@ -780,7 +839,7 @@ function isPlainRecord(candidate) {
 var STATUS_LABELS = new Set(["ready", "blocked", "in-progress", "under-review", "failed", "cancelled"]);
 var FILE_TASK_PATTERN = /\.(task\.)?json$/;
 function createSourceAwareTaskConfigRecordReader(projectRoot, options = {}) {
-  const configPath = options.configPath ?? resolve8(projectRoot, ".rig", "task-config.json");
+  const configPath = options.configPath ?? resolve9(projectRoot, ".rig", "task-config.json");
   const legacy = createLegacyTaskConfigRecordReader(projectRoot, { configPath });
   const spawnFn = options.spawn ?? spawnSync;
   const ghBinary = options.ghBinary ?? "gh";
@@ -863,10 +922,10 @@ function readMaterializedTaskMetadata(entry) {
   return metadata;
 }
 function readConfiguredFilesTaskSourcePath(projectRoot) {
-  const jsonPath = resolve8(projectRoot, "rig.config.json");
-  if (existsSync6(jsonPath)) {
+  const jsonPath = resolve9(projectRoot, "rig.config.json");
+  if (existsSync8(jsonPath)) {
     try {
-      const parsed = JSON.parse(readFileSync5(jsonPath, "utf8"));
+      const parsed = JSON.parse(readFileSync6(jsonPath, "utf8"));
       if (isPlainRecord2(parsed) && isPlainRecord2(parsed.taskSource)) {
         const source = parsed.taskSource;
         return source.kind === "files" && typeof source.path === "string" ? source.path : null;
@@ -875,12 +934,12 @@ function readConfiguredFilesTaskSourcePath(projectRoot) {
       return null;
     }
   }
-  const tsPath = resolve8(projectRoot, "rig.config.ts");
-  if (!existsSync6(tsPath)) {
+  const tsPath = resolve9(projectRoot, "rig.config.ts");
+  if (!existsSync8(tsPath)) {
     return null;
   }
   try {
-    const source = readFileSync5(tsPath, "utf8");
+    const source = readFileSync6(tsPath, "utf8");
     const taskSourceBlock = source.match(/taskSource\s*:\s*\{[\s\S]*?\}/m)?.[0] ?? "";
     const kind = taskSourceBlock.match(/kind\s*:\s*["']([^"']+)["']/)?.[1];
     if (kind !== "files") {
@@ -900,10 +959,10 @@ function readRawTaskEntry(configPath, taskId) {
   return isPlainRecord2(entry) ? entry : null;
 }
 function readRawTaskConfig(configPath) {
-  if (!existsSync6(configPath)) {
+  if (!existsSync8(configPath)) {
     return null;
   }
-  const parsed = JSON.parse(readFileSync5(configPath, "utf8"));
+  const parsed = JSON.parse(readFileSync6(configPath, "utf8"));
   return isPlainRecord2(parsed) ? parsed : null;
 }
 function stripLegacyTaskConfigMetadata2(raw) {
@@ -911,8 +970,8 @@ function stripLegacyTaskConfigMetadata2(raw) {
   return tasks;
 }
 function listFileBackedTasks(projectRoot, sourcePath) {
-  const directory = resolve8(projectRoot, sourcePath);
-  if (!existsSync6(directory)) {
+  const directory = resolve9(projectRoot, sourcePath);
+  if (!existsSync8(directory)) {
     return [];
   }
   const tasks = [];
@@ -927,11 +986,11 @@ function listFileBackedTasks(projectRoot, sourcePath) {
   return tasks;
 }
 function readFileBackedTask(projectRoot, sourcePath, taskId, rawEntry) {
-  const file = findFileBackedTaskFile(resolve8(projectRoot, sourcePath), taskId);
+  const file = findFileBackedTaskFile(resolve9(projectRoot, sourcePath), taskId);
   if (!file) {
     return null;
   }
-  const raw = JSON.parse(readFileSync5(file, "utf8"));
+  const raw = JSON.parse(readFileSync6(file, "utf8"));
   if (!isPlainRecord2(raw)) {
     return null;
   }
@@ -944,7 +1003,7 @@ function readFileBackedTask(projectRoot, sourcePath, taskId, rawEntry) {
   };
 }
 function findFileBackedTaskFile(directory, taskId) {
-  if (!existsSync6(directory)) {
+  if (!existsSync8(directory)) {
     return null;
   }
   for (const name of readdirSync2(directory)) {
@@ -954,7 +1013,7 @@ function findFileBackedTaskFile(directory, taskId) {
     try {
       if (!statSync(file).isFile())
         continue;
-      const raw = JSON.parse(readFileSync5(file, "utf8"));
+      const raw = JSON.parse(readFileSync6(file, "utf8"));
       const inferredId = basename3(file).replace(FILE_TASK_PATTERN, "");
       const id = isPlainRecord2(raw) && typeof raw.id === "string" ? raw.id : inferredId;
       if (id === taskId) {
@@ -1114,8 +1173,8 @@ async function readConfiguredTaskSourceTask(projectRoot, taskId) {
 }
 
 // packages/runtime/src/control-plane/native/task-state.ts
-import { existsSync as existsSync10, readFileSync as readFileSync7, readdirSync as readdirSync3, statSync as statSync3, writeFileSync as writeFileSync5 } from "fs";
-import { basename as basename5, resolve as resolve12 } from "path";
+import { existsSync as existsSync12, readFileSync as readFileSync8, readdirSync as readdirSync3, statSync as statSync3, writeFileSync as writeFileSync6 } from "fs";
+import { basename as basename5, resolve as resolve13 } from "path";
 
 // packages/runtime/src/control-plane/state-sync/types.ts
 var CANONICAL_TASK_LIFECYCLE_STATUSES = new Set([
@@ -1130,46 +1189,46 @@ var CANONICAL_TASK_LIFECYCLE_STATUSES = new Set([
   "cancelled"
 ]);
 // packages/runtime/src/control-plane/native/utils.ts
-import { existsSync as existsSync9, readFileSync as readFileSync6 } from "fs";
-import { resolve as resolve11 } from "path";
+import { existsSync as existsSync11, readFileSync as readFileSync7 } from "fs";
+import { resolve as resolve12 } from "path";
 
 // packages/runtime/src/layout.ts
-import { existsSync as existsSync7 } from "fs";
-import { basename as basename4, dirname as dirname6, resolve as resolve9 } from "path";
+import { existsSync as existsSync9 } from "fs";
+import { basename as basename4, dirname as dirname7, resolve as resolve10 } from "path";
 var RIG_DEFINITION_DIRNAME = "rig";
 var RIG_ARTIFACTS_DIRNAME = "artifacts";
 function resolveMonorepoRoot(projectRoot) {
-  const normalizedProjectRoot = resolve9(projectRoot);
+  const normalizedProjectRoot = resolve10(projectRoot);
   const explicit = process.env.MONOREPO_ROOT?.trim();
   if (explicit) {
-    const explicitRoot = resolve9(explicit);
-    const explicitParent = dirname6(explicitRoot);
+    const explicitRoot = resolve10(explicit);
+    const explicitParent = dirname7(explicitRoot);
     if (basename4(explicitParent) === ".worktrees") {
-      const owner = dirname6(explicitParent);
-      const ownerHasGit = existsSync7(resolve9(owner, ".git"));
-      const ownerHasTaskConfig = existsSync7(resolve9(owner, ".rig", "task-config.json"));
-      const ownerHasRigConfig = existsSync7(resolve9(owner, "rig.config.ts"));
+      const owner = dirname7(explicitParent);
+      const ownerHasGit = existsSync9(resolve10(owner, ".git"));
+      const ownerHasTaskConfig = existsSync9(resolve10(owner, ".rig", "task-config.json"));
+      const ownerHasRigConfig = existsSync9(resolve10(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 (!existsSync7(resolve9(explicitRoot, ".git"))) {
+    if (!existsSync9(resolve10(explicitRoot, ".git"))) {
       throw new Error(`MONOREPO_ROOT points to ${explicitRoot}, but no git checkout was found there.`);
     }
-    const hasTaskConfig = existsSync7(resolve9(explicitRoot, ".rig", "task-config.json"));
-    const hasRigConfig = existsSync7(resolve9(explicitRoot, "rig.config.ts"));
+    const hasTaskConfig = existsSync9(resolve10(explicitRoot, ".rig", "task-config.json"));
+    const hasRigConfig = existsSync9(resolve10(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 = dirname6(normalizedProjectRoot);
+  const projectParent = dirname7(normalizedProjectRoot);
   if (basename4(projectParent) === ".worktrees") {
-    const worktreeOwner = dirname6(projectParent);
-    const ownerHasGit = existsSync7(resolve9(worktreeOwner, ".git"));
-    const ownerHasTaskConfig = existsSync7(resolve9(worktreeOwner, ".rig", "task-config.json"));
-    const ownerHasRigConfig = existsSync7(resolve9(worktreeOwner, "rig.config.ts"));
+    const worktreeOwner = dirname7(projectParent);
+    const ownerHasGit = existsSync9(resolve10(worktreeOwner, ".git"));
+    const ownerHasTaskConfig = existsSync9(resolve10(worktreeOwner, ".rig", "task-config.json"));
+    const ownerHasRigConfig = existsSync9(resolve10(worktreeOwner, "rig.config.ts"));
     if (ownerHasGit && (ownerHasTaskConfig || ownerHasRigConfig)) {
       return worktreeOwner;
     }
@@ -1177,28 +1236,28 @@ function resolveMonorepoRoot(projectRoot) {
   return normalizedProjectRoot;
 }
 function resolveRuntimeWorkspaceLayout(workspaceDir) {
-  const root = resolve9(workspaceDir);
-  const rigRoot = resolve9(root, ".rig");
-  const logsDir = resolve9(rigRoot, "logs");
-  const stateDir = resolve9(rigRoot, "state");
-  const runtimeDir = resolve9(rigRoot, "runtime");
-  const binDir = resolve9(rigRoot, "bin");
+  const root = resolve10(workspaceDir);
+  const rigRoot = resolve10(root, ".rig");
+  const logsDir = resolve10(rigRoot, "logs");
+  const stateDir = resolve10(rigRoot, "state");
+  const runtimeDir = resolve10(rigRoot, "runtime");
+  const binDir = resolve10(rigRoot, "bin");
   return {
     workspaceDir: root,
     rigRoot,
     stateDir,
     logsDir,
-    artifactsRoot: resolve9(root, RIG_ARTIFACTS_DIRNAME),
+    artifactsRoot: resolve10(root, RIG_ARTIFACTS_DIRNAME),
     runtimeDir,
-    homeDir: resolve9(rigRoot, "home"),
-    tmpDir: resolve9(rigRoot, "tmp"),
-    cacheDir: resolve9(rigRoot, "cache"),
-    sessionDir: resolve9(rigRoot, "session"),
+    homeDir: resolve10(rigRoot, "home"),
+    tmpDir: resolve10(rigRoot, "tmp"),
+    cacheDir: resolve10(rigRoot, "cache"),
+    sessionDir: resolve10(rigRoot, "session"),
     binDir,
-    distDir: resolve9(rigRoot, "dist"),
-    pluginBinDir: resolve9(binDir, "plugins"),
-    contextPath: resolve9(rigRoot, "runtime-context.json"),
-    controlPlaneEventsFile: resolve9(logsDir, "control-plane.events.jsonl")
+    distDir: resolve10(rigRoot, "dist"),
+    pluginBinDir: resolve10(binDir, "plugins"),
+    contextPath: resolve10(rigRoot, "runtime-context.json"),
+    controlPlaneEventsFile: resolve10(logsDir, "control-plane.events.jsonl")
   };
 }
 function resolveActiveRuntimeWorkspaceRoot(monorepoRoot) {
@@ -1206,14 +1265,14 @@ function resolveActiveRuntimeWorkspaceRoot(monorepoRoot) {
   if (!explicit) {
     throw new Error("No active runtime workspace. Set RIG_TASK_WORKSPACE or provision a task runtime first.");
   }
-  return resolve9(explicit);
+  return resolve10(explicit);
 }
 function resolveRigLayout(projectRoot) {
   const monorepoRoot = resolveMonorepoRoot(projectRoot);
-  const definitionRoot = resolve9(projectRoot, RIG_DEFINITION_DIRNAME);
+  const definitionRoot = resolve10(projectRoot, RIG_DEFINITION_DIRNAME);
   const runtimeWorkspaceRoot = resolveActiveRuntimeWorkspaceRoot(monorepoRoot);
   const runtimeLayout = resolveRuntimeWorkspaceLayout(runtimeWorkspaceRoot);
-  const policyDir = resolve9(definitionRoot, "policy");
+  const policyDir = resolve10(definitionRoot, "policy");
   return {
     projectRoot,
     monorepoRoot,
@@ -1221,48 +1280,48 @@ function resolveRigLayout(projectRoot) {
     runtimeWorkspaceRoot,
     stateRoot: runtimeLayout.rigRoot,
     artifactsRoot: runtimeLayout.artifactsRoot,
-    configPath: resolve9(definitionRoot, "config.sh"),
-    taskConfigPath: resolve9(runtimeWorkspaceRoot, ".rig", "task-config.json"),
+    configPath: resolve10(definitionRoot, "config.sh"),
+    taskConfigPath: resolve10(runtimeWorkspaceRoot, ".rig", "task-config.json"),
     policyDir,
-    policyFile: resolve9(policyDir, "policy.json"),
-    pluginsDir: resolve9(definitionRoot, "plugins"),
-    hooksDir: resolve9(definitionRoot, "hooks"),
-    toolsDir: resolve9(definitionRoot, "tools"),
-    templatesDir: resolve9(definitionRoot, "templates"),
-    validationDir: resolve9(definitionRoot, "validation"),
+    policyFile: resolve10(policyDir, "policy.json"),
+    pluginsDir: resolve10(definitionRoot, "plugins"),
+    hooksDir: resolve10(definitionRoot, "hooks"),
+    toolsDir: resolve10(definitionRoot, "tools"),
+    templatesDir: resolve10(definitionRoot, "templates"),
+    validationDir: resolve10(definitionRoot, "validation"),
     stateDir: runtimeLayout.stateDir,
     logsDir: runtimeLayout.logsDir,
-    notificationsDir: resolve9(definitionRoot, "notifications"),
+    notificationsDir: resolve10(definitionRoot, "notifications"),
     runtimeDir: runtimeLayout.runtimeDir,
     distDir: runtimeLayout.distDir,
     binDir: runtimeLayout.binDir,
     pluginBinDir: runtimeLayout.pluginBinDir,
-    keybindingsPath: resolve9(definitionRoot, "keybindings.json"),
+    keybindingsPath: resolve10(definitionRoot, "keybindings.json"),
     controlPlaneEventsFile: runtimeLayout.controlPlaneEventsFile
   };
 }
 
 // packages/runtime/src/control-plane/native/runtime-native.ts
 import { dlopen, ptr, suffix, toBuffer } from "bun:ffi";
-import { copyFileSync, existsSync as existsSync8, mkdirSync as mkdirSync4, renameSync, rmSync as rmSync2, statSync as statSync2 } from "fs";
+import { copyFileSync, existsSync as existsSync10, mkdirSync as mkdirSync5, renameSync, rmSync as rmSync2, statSync as statSync2 } from "fs";
 import { tmpdir as tmpdir4 } from "os";
-import { dirname as dirname7, resolve as resolve10 } from "path";
-var sharedNativeRuntimeOutputDir = resolve10(tmpdir4(), "rig-native");
-var sharedNativeRuntimeOutputPath = resolve10(sharedNativeRuntimeOutputDir, `runtime-native-${process.platform}-${process.arch}.${suffix}`);
+import { dirname as dirname8, resolve as resolve11 } from "path";
+var sharedNativeRuntimeOutputDir = resolve11(tmpdir4(), "rig-native");
+var sharedNativeRuntimeOutputPath = resolve11(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 && existsSync8(outputPath) ? outputPath : null;
+  return !options.force && existsSync10(outputPath) ? outputPath : null;
 }
 async function loadNativeRuntimeLibrary() {
   if (process.env.RIG_DISABLE_ZIG_NATIVE === "1") {
     return null;
   }
   for (const candidate of nativeRuntimeLibraryCandidates()) {
-    if (!candidate || !existsSync8(candidate)) {
+    if (!candidate || !existsSync10(candidate)) {
       continue;
     }
     const loaded = tryDlopenNativeRuntimeLibrary(candidate);
@@ -1278,12 +1337,12 @@ async function loadNativeRuntimeLibrary() {
 }
 function nativePackageLibraryCandidates(fromDir, names) {
   const candidates = [];
-  let cursor = resolve10(fromDir);
+  let cursor = resolve11(fromDir);
   for (let index = 0;index < 8; index += 1) {
     for (const name of names) {
-      candidates.push(resolve10(cursor, "native", `${process.platform}-${process.arch}`, name), resolve10(cursor, "native", `${process.platform}-${process.arch}`, "lib", name), resolve10(cursor, "native", name), resolve10(cursor, "native", "lib", name));
+      candidates.push(resolve11(cursor, "native", `${process.platform}-${process.arch}`, name), resolve11(cursor, "native", `${process.platform}-${process.arch}`, "lib", name), resolve11(cursor, "native", name), resolve11(cursor, "native", "lib", name));
     }
-    const parent = dirname7(cursor);
+    const parent = dirname8(cursor);
     if (parent === cursor)
       break;
     cursor = parent;
@@ -1292,27 +1351,27 @@ function nativePackageLibraryCandidates(fromDir, names) {
 }
 function nativeRuntimeLibraryCandidates() {
   const explicit = process.env.RIG_NATIVE_RUNTIME_LIB?.trim() || "";
-  const execDir = process.execPath?.trim() ? dirname7(process.execPath.trim()) : "";
+  const execDir = process.execPath?.trim() ? dirname8(process.execPath.trim()) : "";
   const platformSpecific = `runtime-native-${process.platform}-${process.arch}.${suffix}`;
   return [...new Set([
     explicit,
     ...nativePackageLibraryCandidates(import.meta.dir, [colocatedNativeRuntimeFileName, platformSpecific]),
-    execDir ? resolve10(execDir, colocatedNativeRuntimeFileName) : "",
-    execDir ? resolve10(execDir, platformSpecific) : "",
-    execDir ? resolve10(execDir, "..", colocatedNativeRuntimeFileName) : "",
-    execDir ? resolve10(execDir, "..", platformSpecific) : "",
-    execDir ? resolve10(execDir, "lib", colocatedNativeRuntimeFileName) : "",
-    execDir ? resolve10(execDir, "..", "lib", colocatedNativeRuntimeFileName) : "",
+    execDir ? resolve11(execDir, colocatedNativeRuntimeFileName) : "",
+    execDir ? resolve11(execDir, platformSpecific) : "",
+    execDir ? resolve11(execDir, "..", colocatedNativeRuntimeFileName) : "",
+    execDir ? resolve11(execDir, "..", platformSpecific) : "",
+    execDir ? resolve11(execDir, "lib", colocatedNativeRuntimeFileName) : "",
+    execDir ? resolve11(execDir, "..", "lib", colocatedNativeRuntimeFileName) : "",
     sharedNativeRuntimeOutputPath
   ].filter(Boolean))];
 }
 function resolveNativeRuntimeSourcePath() {
   const explicit = process.env.RIG_NATIVE_RUNTIME_SOURCE?.trim();
-  if (explicit && existsSync8(explicit)) {
+  if (explicit && existsSync10(explicit)) {
     return explicit;
   }
-  const bundled = resolve10(import.meta.dir, "../../../native/snapshot.zig");
-  return existsSync8(bundled) ? bundled : null;
+  const bundled = resolve11(import.meta.dir, "../../../native/snapshot.zig");
+  return existsSync10(bundled) ? bundled : null;
 }
 async function buildNativeRuntimeLibrary(outputPath, options = {}) {
   if (process.env.RIG_DISABLE_ZIG_NATIVE === "1") {
@@ -1325,8 +1384,8 @@ async function buildNativeRuntimeLibrary(outputPath, options = {}) {
   }
   const tempOutputPath = `${outputPath}.${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2)}.tmp`;
   try {
-    mkdirSync4(dirname7(outputPath), { recursive: true });
-    const needsBuild = options.force === true || !existsSync8(outputPath) || statSync2(sourcePath).mtimeMs > statSync2(outputPath).mtimeMs;
+    mkdirSync5(dirname8(outputPath), { recursive: true });
+    const needsBuild = options.force === true || !existsSync10(outputPath) || statSync2(sourcePath).mtimeMs > statSync2(outputPath).mtimeMs;
     if (!needsBuild) {
       return true;
     }
@@ -1344,7 +1403,7 @@ async function buildNativeRuntimeLibrary(outputPath, options = {}) {
       stderr: "pipe"
     });
     const exitCode = await build.exited;
-    if (exitCode !== 0 || !existsSync8(tempOutputPath)) {
+    if (exitCode !== 0 || !existsSync10(tempOutputPath)) {
       rmSync2(tempOutputPath, { force: true });
       return false;
     }
@@ -1431,11 +1490,11 @@ function runCapture(command, cwd, env) {
   };
 }
 function readJsonFile(path, fallback) {
-  if (!existsSync9(path)) {
+  if (!existsSync11(path)) {
     return fallback;
   }
   try {
-    return JSON.parse(readFileSync6(path, "utf-8"));
+    return JSON.parse(readFileSync7(path, "utf-8"));
   } catch {
     return fallback;
   }
@@ -1446,31 +1505,31 @@ function nowIso() {
 function resolveHarnessPaths(projectRoot) {
   const hasRuntimeWorkspace = Boolean(process.env.RIG_TASK_WORKSPACE?.trim());
   const monorepoRoot = resolveMonorepoRoot2(projectRoot);
-  const harnessRoot = resolve11(projectRoot, "rig");
-  const stateRoot = resolve11(projectRoot, ".rig");
+  const harnessRoot = resolve12(projectRoot, "rig");
+  const stateRoot = resolve12(projectRoot, ".rig");
   const layout = hasRuntimeWorkspace ? resolveRigLayout(projectRoot) : null;
-  const stateDir = layout?.stateDir ?? resolve11(stateRoot, "state");
-  const logsDir = layout?.logsDir ?? resolve11(stateRoot, "logs");
-  const artifactsDir = layout?.artifactsRoot ?? resolve11(monorepoRoot, "artifacts");
-  const taskConfigPath = layout?.taskConfigPath ?? resolve11(monorepoRoot, ".rig", "task-config.json");
-  const binDir = layout?.binDir ?? resolve11(stateRoot, "bin");
+  const stateDir = layout?.stateDir ?? resolve12(stateRoot, "state");
+  const logsDir = layout?.logsDir ?? resolve12(stateRoot, "logs");
+  const artifactsDir = layout?.artifactsRoot ?? resolve12(monorepoRoot, "artifacts");
+  const taskConfigPath = layout?.taskConfigPath ?? resolve12(monorepoRoot, ".rig", "task-config.json");
+  const binDir = layout?.binDir ?? resolve12(stateRoot, "bin");
   return {
     harnessRoot,
     stateDir: process.env.RIG_STATE_DIR || stateDir,
     artifactsDir,
     logsDir: process.env.RIG_LOGS_DIR || logsDir,
     binDir,
-    hooksDir: resolve11(harnessRoot, "hooks"),
-    validationDir: resolve11(harnessRoot, "validation"),
+    hooksDir: resolve12(harnessRoot, "hooks"),
+    validationDir: resolve12(harnessRoot, "validation"),
     taskConfigPath,
-    sessionPath: process.env.RIG_SESSION_FILE || resolve11(stateRoot, "session", "session.json"),
+    sessionPath: process.env.RIG_SESSION_FILE || resolve12(stateRoot, "session", "session.json"),
     monorepoRoot,
-    tsApiTestsDir: process.env.TS_API_TESTS_DIR || resolve11(monorepoRoot, "TSAPITests"),
-    taskRepoCommitsPath: resolve11(stateDir, "task-repo-commits.json"),
-    baseRepoPinsPath: resolve11(stateDir, "base-repo-pins.json"),
-    failedApproachesPath: resolve11(stateDir, "failed_approaches.md"),
-    agentProfilePath: resolve11(stateDir, "agent-profile.json"),
-    reviewProfilePath: resolve11(stateDir, "review-profile.json")
+    tsApiTestsDir: process.env.TS_API_TESTS_DIR || resolve12(monorepoRoot, "TSAPITests"),
+    taskRepoCommitsPath: resolve12(stateDir, "task-repo-commits.json"),
+    baseRepoPinsPath: resolve12(stateDir, "base-repo-pins.json"),
+    failedApproachesPath: resolve12(stateDir, "failed_approaches.md"),
+    agentProfilePath: resolve12(stateDir, "agent-profile.json"),
+    reviewProfilePath: resolve12(stateDir, "review-profile.json")
   };
 }
 // packages/runtime/src/control-plane/state-sync/reconcile.ts
@@ -1525,25 +1584,25 @@ function lookupTask(projectRoot, input) {
 function artifactDirForId(projectRoot, id) {
   const workspaceDir = process.env.RIG_TASK_WORKSPACE?.trim();
   if (workspaceDir) {
-    const worktreeArtifacts = resolve12(workspaceDir, "artifacts", id);
-    if (existsSync10(worktreeArtifacts) || existsSync10(resolve12(workspaceDir, "artifacts"))) {
+    const worktreeArtifacts = resolve13(workspaceDir, "artifacts", id);
+    if (existsSync12(worktreeArtifacts) || existsSync12(resolve13(workspaceDir, "artifacts"))) {
       return worktreeArtifacts;
     }
   }
   try {
     const paths = resolveHarnessPaths(projectRoot);
-    return resolve12(paths.artifactsDir, id);
+    return resolve13(paths.artifactsDir, id);
   } catch {
-    return resolve12(resolveMonorepoRoot2(projectRoot), "artifacts", id);
+    return resolve13(resolveMonorepoRoot2(projectRoot), "artifacts", id);
   }
 }
 function resolveTaskConfigPath(projectRoot) {
   const paths = resolveHarnessPaths(projectRoot);
-  if (existsSync10(paths.taskConfigPath)) {
+  if (existsSync12(paths.taskConfigPath)) {
     return paths.taskConfigPath;
   }
   for (const candidate of sourceTaskConfigCandidates(projectRoot)) {
-    if (existsSync10(candidate)) {
+    if (existsSync12(candidate)) {
       return candidate;
     }
   }
@@ -1551,7 +1610,7 @@ function resolveTaskConfigPath(projectRoot) {
 }
 function findSourceTaskConfigPath(projectRoot) {
   for (const candidate of sourceTaskConfigCandidates(projectRoot)) {
-    if (existsSync10(candidate)) {
+    if (existsSync12(candidate)) {
       return candidate;
     }
   }
@@ -1564,7 +1623,7 @@ function readAndSyncSourceTaskConfig(projectRoot) {
   const synced = synchronizeTaskConfigWithTracker(projectRoot, raw);
   if (sourcePath && synced.updated) {
     try {
-      writeFileSync5(sourcePath, `${JSON.stringify(synced.config, null, 2)}
+      writeFileSync6(sourcePath, `${JSON.stringify(synced.config, null, 2)}
 `, "utf-8");
     } catch {}
   }
@@ -1616,12 +1675,12 @@ function shouldRefreshAutoSyncedTaskConfigEntry(entry) {
   return !candidate.role;
 }
 function readSourceIssueRecords(projectRoot) {
-  const issuesPath = resolve12(resolveMonorepoRoot2(projectRoot), ".beads", "issues.jsonl");
-  if (!existsSync10(issuesPath)) {
+  const issuesPath = resolve13(resolveMonorepoRoot2(projectRoot), ".beads", "issues.jsonl");
+  if (!existsSync12(issuesPath)) {
     return [];
   }
   const records = [];
-  for (const line of readFileSync7(issuesPath, "utf-8").split(/\r?\n/)) {
+  for (const line of readFileSync8(issuesPath, "utf-8").split(/\r?\n/)) {
     const trimmed = line.trim();
     if (!trimmed) {
       continue;
@@ -1677,19 +1736,19 @@ function readConfiguredFileTaskConfig(projectRoot) {
   if (!sourcePath) {
     return {};
   }
-  const directory = resolve12(projectRoot, sourcePath);
-  if (!existsSync10(directory)) {
+  const directory = resolve13(projectRoot, sourcePath);
+  if (!existsSync12(directory)) {
     return {};
   }
   const config = {};
   for (const name of readdirSync3(directory)) {
     if (!FILE_TASK_PATTERN2.test(name))
       continue;
-    const file = resolve12(directory, name);
+    const file = resolve13(directory, name);
     try {
       if (!statSync3(file).isFile())
         continue;
-      const raw = JSON.parse(readFileSync7(file, "utf8"));
+      const raw = JSON.parse(readFileSync8(file, "utf8"));
       if (!raw || typeof raw !== "object" || Array.isArray(raw))
         continue;
       const record = raw;
@@ -1731,10 +1790,10 @@ function firstStringList2(...candidates) {
   return [];
 }
 function readConfiguredFilesTaskSourcePath2(projectRoot) {
-  const jsonPath = resolve12(projectRoot, "rig.config.json");
-  if (existsSync10(jsonPath)) {
+  const jsonPath = resolve13(projectRoot, "rig.config.json");
+  if (existsSync12(jsonPath)) {
     try {
-      const parsed = JSON.parse(readFileSync7(jsonPath, "utf8"));
+      const parsed = JSON.parse(readFileSync8(jsonPath, "utf8"));
       if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
         const taskSource = parsed.taskSource;
         if (taskSource && typeof taskSource === "object" && !Array.isArray(taskSource)) {
@@ -1746,12 +1805,12 @@ function readConfiguredFilesTaskSourcePath2(projectRoot) {
       return null;
     }
   }
-  const tsPath = resolve12(projectRoot, "rig.config.ts");
-  if (!existsSync10(tsPath)) {
+  const tsPath = resolve13(projectRoot, "rig.config.ts");
+  if (!existsSync12(tsPath)) {
     return null;
   }
   try {
-    const source = readFileSync7(tsPath, "utf8");
+    const source = readFileSync8(tsPath, "utf8");
     const taskSourceBlock = source.match(/taskSource\s*:\s*\{[\s\S]*?\}/m)?.[0] ?? "";
     const kind = taskSourceBlock.match(/kind\s*:\s*["']([^"']+)["']/)?.[1];
     if (kind !== "files") {
@@ -1765,9 +1824,9 @@ function readConfiguredFilesTaskSourcePath2(projectRoot) {
 function sourceTaskConfigCandidates(projectRoot) {
   const runtimeContext = loadRuntimeContextFromEnv();
   return [
-    runtimeContext?.monorepoMainRoot ? resolve12(runtimeContext.monorepoMainRoot, ".rig", "task-config.json") : "",
-    process.env.MONOREPO_MAIN_ROOT?.trim() ? resolve12(process.env.MONOREPO_MAIN_ROOT.trim(), ".rig", "task-config.json") : "",
-    resolve12(resolveMonorepoRoot2(projectRoot), ".rig", "task-config.json")
+    runtimeContext?.monorepoMainRoot ? resolve13(runtimeContext.monorepoMainRoot, ".rig", "task-config.json") : "",
+    process.env.MONOREPO_MAIN_ROOT?.trim() ? resolve13(process.env.MONOREPO_MAIN_ROOT.trim(), ".rig", "task-config.json") : "",
+    resolve13(resolveMonorepoRoot2(projectRoot), ".rig", "task-config.json")
   ].filter(Boolean);
 }
 
@@ -3065,12 +3124,12 @@ var TASK_ARTIFACT_STAGE_FALLBACK = new Set([
   "validation-summary.json"
 ]);
 function readPrMetadata(projectRoot, taskId) {
-  const path = resolve13(artifactDirForId(projectRoot, taskId), "pr-state.json");
-  if (!existsSync11(path)) {
+  const path = resolve14(artifactDirForId(projectRoot, taskId), "pr-state.json");
+  if (!existsSync13(path)) {
     return [];
   }
   try {
-    const parsed = JSON.parse(readFileSync8(path, "utf-8"));
+    const parsed = JSON.parse(readFileSync9(path, "utf-8"));
     if (!parsed || typeof parsed !== "object") {
       return [];
     }
@@ -3096,11 +3155,11 @@ async function verifyTask(options) {
   const taskId = options.taskId;
   const normalizedTaskId = lookupTask(options.projectRoot, taskId);
   const artifactDir = artifactDirForId(options.projectRoot, taskId);
-  mkdirSync6(artifactDir, { recursive: true });
-  const validationSummaryPath = resolve14(artifactDir, "validation-summary.json");
-  const reviewFeedbackPath = resolve14(artifactDir, "review-feedback.md");
-  const reviewStatePath = resolve14(artifactDir, "review-state.json");
-  const greptileRawPath = resolve14(artifactDir, "review-greptile-raw.json");
+  mkdirSync7(artifactDir, { recursive: true });
+  const validationSummaryPath = resolve15(artifactDir, "validation-summary.json");
+  const reviewFeedbackPath = resolve15(artifactDir, "review-feedback.md");
+  const reviewStatePath = resolve15(artifactDir, "review-state.json");
+  const greptileRawPath = resolve15(artifactDir, "review-greptile-raw.json");
   const prStates = readPrMetadata(options.projectRoot, taskId);
   const prState = prStates[0] || null;
   const localReasons = [];
@@ -3112,7 +3171,7 @@ async function verifyTask(options) {
   if (!normalizedTaskId && !await hasConfiguredSourceTask(options.projectRoot, taskId)) {
     localReasons.push(`[Task Config] Unknown task id '${taskId}' in task-config or configured task source.`);
   }
-  if (!existsSync12(validationSummaryPath)) {
+  if (!existsSync14(validationSummaryPath)) {
     localReasons.push(`[Artifact Quality] validation-summary.json not found at ${validationSummaryPath}.`);
   } else {
     const summary = await parseValidationSummary(validationSummaryPath);
@@ -3121,13 +3180,13 @@ async function verifyTask(options) {
     }
   }
   for (const file of ["task-result.json", "decision-log.md", "next-actions.md", "changed-files.txt"]) {
-    const requiredPath = resolve14(artifactDir, file);
-    if (!existsSync12(requiredPath)) {
+    const requiredPath = resolve15(artifactDir, file);
+    if (!existsSync14(requiredPath)) {
       localReasons.push(`[Artifact Quality] Missing required artifact file: ${requiredPath}`);
     }
   }
-  const taskResultPath = resolve14(artifactDir, "task-result.json");
-  if (existsSync12(taskResultPath)) {
+  const taskResultPath = resolve15(artifactDir, "task-result.json");
+  if (existsSync14(taskResultPath)) {
     const taskResult = await readJsonFile2(taskResultPath);
     const artifactStatus = typeof taskResult?.status === "string" ? taskResult.status.trim().toLowerCase() : "";
     if (artifactStatus === "partial") {
@@ -3140,8 +3199,8 @@ async function verifyTask(options) {
       localReasons.push("[Artifact Quality] task-result.json next actions indicate remaining implementation scope.");
     }
   }
-  const nextActionsPath = resolve14(artifactDir, "next-actions.md");
-  if (existsSync12(nextActionsPath)) {
+  const nextActionsPath = resolve15(artifactDir, "next-actions.md");
+  if (existsSync14(nextActionsPath)) {
     const nextActionsContent = await Bun.file(nextActionsPath).text();
     if (nextActionsContent.includes("TODO: Replace this scaffold") || nextActionsContent.includes("bd-<downstream-task-id>")) {
       localReasons.push("[Artifact Quality] next-actions.md still contains scaffold placeholder text. Replace with real recommendations.");
@@ -3172,7 +3231,7 @@ async function verifyTask(options) {
       aiReasons.push(`[AI Review] Required mode needs a completed Greptile approval; current verdict is ${ai.verdict}.`);
     }
     if (persistArtifacts && ai.rawResponse) {
-      writeFileSync7(greptileRawPath, `${ai.rawResponse}
+      writeFileSync8(greptileRawPath, `${ai.rawResponse}
 `, "utf-8");
     }
   } else if (!options.skipAiReview && reviewMode === "off") {
@@ -3415,7 +3474,7 @@ function evaluateSourceCloseoutChecks(prState, prLabel) {
   if (!Array.isArray(checks) || checks.length === 0) {
     return [`[Source Issue] PR ${prLabel} must have green check evidence before completion.`];
   }
-  const ciGate = evaluatePullRequestCiChecks(checks, "PR", 0);
+  const ciGate = evaluatePullRequestCiChecks(checks, "PR", 0, { mergeStateStatus: prState.mergeStateStatus });
   if (ciGate.verdict === "APPROVE") {
     return [];
   }
@@ -3511,7 +3570,7 @@ function isAcceptedValidationSummary(summary) {
   return summary.status === "skipped" && summary.total === 0 && summary.failed === 0;
 }
 async function loadReviewMode(reviewProfilePath, fallback) {
-  const parsed = existsSync12(reviewProfilePath) ? await readJsonFile2(reviewProfilePath) : null;
+  const parsed = existsSync14(reviewProfilePath) ? await readJsonFile2(reviewProfilePath) : null;
   const mode = parsed?.mode;
   if (mode === "off" || mode === "advisory" || mode === "required") {
     return mode;
@@ -3522,7 +3581,7 @@ async function loadReviewMode(reviewProfilePath, fallback) {
   return "advisory";
 }
 async function loadReviewProvider(reviewProfilePath, fallback) {
-  const parsed = existsSync12(reviewProfilePath) ? await readJsonFile2(reviewProfilePath) : null;
+  const parsed = existsSync14(reviewProfilePath) ? await readJsonFile2(reviewProfilePath) : null;
   const provider = parsed?.provider;
   if (typeof provider === "string" && provider.trim().length > 0) {
     return provider;
@@ -3681,7 +3740,7 @@ function writeFeedbackFile(options) {
   if (options.aiRawFeedback) {
     lines.push("## Raw Reviewer Feedback", "", "```text", options.aiRawFeedback, "```", "");
   }
-  writeFileSync7(options.output, `${lines.join(`
+  writeFileSync8(options.output, `${lines.join(`
 `)}
 `, "utf-8");
 }
@@ -3698,7 +3757,7 @@ function writeReviewStateFile(options) {
     ai_warnings: options.aiWarnings,
     updated_at: nowIso()
   };
-  writeFileSync7(options.output, `${JSON.stringify(payload, null, 2)}
+  writeFileSync8(options.output, `${JSON.stringify(payload, null, 2)}
 `, "utf-8");
 }
 async function runGreptileReviewForPr(options) {
@@ -3779,7 +3838,7 @@ async function runGreptileReviewForPr(options) {
     }
     await Bun.sleep(options.pollIntervalMs);
   }
-  const ciGate = evaluatePullRequestCiChecks(githubCheckRollup, repoName, prNumber);
+  const ciGate = evaluatePullRequestCiChecks(githubCheckRollup, repoName, prNumber, { mergeStateStatus: options.prState.mergeStateStatus });
   if (ciGate.verdict !== "APPROVE") {
     return {
       verdict: ciGate.verdict,
@@ -4037,7 +4096,7 @@ async function runGithubGreptileFallbackReviewForPr(options) {
     }
     await Bun.sleep(options.pollIntervalMs);
   }
-  const ciGate = evaluatePullRequestCiChecks(checkRollup, repoName, prNumber);
+  const ciGate = evaluatePullRequestCiChecks(checkRollup, repoName, prNumber, { mergeStateStatus: options.prState.mergeStateStatus });
   if (ciGate.verdict !== "APPROVE") {
     return {
       verdict: ciGate.verdict,
@@ -4392,19 +4451,31 @@ function loadGithubPullRequestCheckRollup(projectRoot, repoName, prNumber) {
   ]);
   return response.statusCheckRollup || [];
 }
-function evaluatePullRequestCiChecks(checks, repoName, prNumber) {
-  const nonGreptileChecks = checks.filter((check) => {
-    const label = (check.name || check.context || "").toLowerCase();
-    return label.length > 0 && !label.includes("greptile");
-  });
-  const pending = nonGreptileChecks.filter((check) => {
+function evaluatePullRequestCiChecks(checks, repoName, prNumber, options = {}) {
+  const isPendingCheck2 = (check) => {
     if ((check.__typename || "") === "CheckRun") {
       return (check.status || "").toUpperCase() !== "COMPLETED";
     }
     const state = (check.state || check.status || "").toUpperCase();
     return state === "PENDING" || state === "EXPECTED" || state === "QUEUED" || state === "IN_PROGRESS";
+  };
+  const pendingGreptile = checks.filter((check) => {
+    const label = (check.name || check.context || "").toLowerCase();
+    return label.includes("greptile") && isPendingCheck2(check);
+  });
+  if (pendingGreptile.length > 0) {
+    return {
+      verdict: "SKIP",
+      reasons: pendingGreptile.map((check) => `[CI] ${repoName}#${prNumber} mandatory Greptile check is still pending: ${check.name || check.context || "unknown"}.`)
+    };
+  }
+  const nonGreptileChecks = checks.filter((check) => {
+    const label = (check.name || check.context || "").toLowerCase();
+    return label.length > 0 && !label.includes("greptile");
   });
-  if (pending.length > 0) {
+  const pending = nonGreptileChecks.filter(isPendingCheck2);
+  const mergeClean = (options.mergeStateStatus || "").toUpperCase() === "CLEAN";
+  if (pending.length > 0 && !mergeClean) {
     return {
       verdict: "SKIP",
       reasons: pending.map((check) => `[CI] ${repoName}#${prNumber} check is still pending: ${check.name || check.context || "unknown"}.`)
@@ -4488,7 +4559,7 @@ function filterActionableGithubGreptileThreads(threads) {
 }
 function resolvePrRepoRoot(projectRoot, prState) {
   const runtimeWorkspace = process.env.RIG_TASK_WORKSPACE?.trim();
-  if (prState.target === "monorepo" && runtimeWorkspace && existsSync12(resolve14(runtimeWorkspace, ".git"))) {
+  if (prState.target === "monorepo" && runtimeWorkspace && existsSync14(resolve15(runtimeWorkspace, ".git"))) {
     return runtimeWorkspace;
   }
   const paths = resolveHarnessPaths(projectRoot);
@@ -4538,5 +4609,6 @@ export {
   verifyTask,
   pickRelevantCodeReview,
   filterActionableGreptileComments,
+  evaluatePullRequestCiChecks,
   __testOnly
 };