@h-rig/runtime 0.0.6-alpha.2 → 0.0.6-alpha.21

package/dist/bin/rig-agent-dispatch.js

@@ -2951,34 +2951,6 @@ async function readSourceAwareTaskStatus(projectRoot, taskId, options = {}) {
     return null;
   }
 }
-function updateSourceAwareTaskConfigTask(projectRoot, taskId, update, options = {}) {
-  const configPath = options.configPath ?? resolve13(projectRoot, ".rig", "task-config.json");
-  const rawEntry = readRawTaskEntry(configPath, taskId);
-  if (!rawEntry) {
-    const configuredFilesPath = readConfiguredFilesTaskSourcePath(projectRoot);
-    return configuredFilesPath ? updateFileBackedTask(projectRoot, configuredFilesPath, taskId, update) : false;
-  }
-  const metadata = readMaterializedTaskMetadata(rawEntry);
-  const source = metadata.taskSource;
-  if (source?.kind === "github-issues") {
-    applyGithubIssueUpdate(options.ghBinary ?? "gh", options.spawn ?? spawnSync, taskId, metadata, update);
-    return true;
-  }
-  if (source?.kind === "files" && source.path) {
-    return updateFileBackedTask(projectRoot, source.path, taskId, update);
-  }
-  if (source?.kind && source.kind !== "files" && source.kind !== "legacy-task-config") {
-    return false;
-  }
-  if (!source && options.allowLocalTaskConfigStatusFallback === false) {
-    return false;
-  }
-  if (typeof update.status !== "string" || update.status.trim().length === 0) {
-    return false;
-  }
-  writeLegacyTaskStatus(configPath, taskId, update.status);
-  return true;
-}
 function readMaterializedTaskMetadata(entry) {
   const rawRig = entry._rig;
   if (!isPlainRecord2(rawRig)) {
@@ -3052,46 +3024,6 @@ function stripLegacyTaskConfigMetadata2(raw) {
   const { validation_descriptions: _legacyDescriptions, _meta, ...tasks } = raw;
   return tasks;
 }
-function writeLegacyTaskStatus(configPath, taskId, status) {
-  const rawConfig = readRawTaskConfig(configPath);
-  if (!rawConfig) {
-    return;
-  }
-  const entry = rawConfig[taskId];
-  if (!isPlainRecord2(entry)) {
-    return;
-  }
-  entry.status = status;
-  writeFileSync5(configPath, `${JSON.stringify(rawConfig, null, 2)}
-`, "utf8");
-}
-function updateFileBackedTask(projectRoot, sourcePath, taskId, update) {
-  const directory = resolve13(projectRoot, sourcePath);
-  const file = findFileBackedTaskFile(directory, taskId);
-  if (!file) {
-    return false;
-  }
-  const raw = JSON.parse(readFileSync6(file, "utf8"));
-  if (!isPlainRecord2(raw)) {
-    return false;
-  }
-  if (update.status)
-    raw.status = update.status;
-  if (update.title !== undefined)
-    raw.title = update.title;
-  if (update.body !== undefined)
-    raw.body = update.body;
-  if (update.comment?.trim()) {
-    const existing = Array.isArray(raw.comments) ? raw.comments : [];
-    raw.comments = [
-      ...existing,
-      { body: update.comment, createdAt: new Date().toISOString(), source: "rig" }
-    ];
-  }
-  writeFileSync5(file, `${JSON.stringify(raw, null, 2)}
-`, "utf8");
-  return true;
-}
 function listFileBackedTasks(projectRoot, sourcePath) {
   const directory = resolve13(projectRoot, sourcePath);
   if (!existsSync13(directory)) {
@@ -3159,26 +3091,6 @@ function readGithubIssueTask(bin, spawnFn, id, metadata, rawEntry) {
   ], spawnFn);
   return githubIssueToTask(issue, source, rawEntry);
 }
-function applyGithubIssueUpdate(bin, spawnFn, id, metadata, update) {
-  const source = requireGithubIssueSource(metadata, id);
-  const repo = `${source.owner}/${source.repo}`;
-  if (update.status) {
-    applyGithubIssueStatus(bin, repo, spawnFn, id, update.status);
-  }
-  if (typeof update.comment === "string" && update.comment.trim().length > 0) {
-    runGhVoid(bin, ["issue", "comment", String(id), "--repo", repo, "--body", update.comment], spawnFn);
-  }
-  const editArgs = ["issue", "edit", String(id), "--repo", repo];
-  if (typeof update.title === "string" && update.title.trim().length > 0) {
-    editArgs.push("--title", update.title.trim());
-  }
-  if (typeof update.body === "string") {
-    editArgs.push("--body", update.body);
-  }
-  if (editArgs.length > 5) {
-    runGhVoid(bin, editArgs, spawnFn);
-  }
-}
 function requireGithubIssueSource(metadata, id) {
   const source = metadata.taskSource;
   if (source?.kind === "github-issues" && source.owner && source.repo) {
@@ -3238,76 +3150,9 @@ function githubStatusFor(issue) {
     return "cancelled";
   return "open";
 }
-function applyGithubIssueStatus(bin, repo, spawnFn, id, status) {
-  if (status === "closed") {
-    runGhVoid(bin, ["issue", "close", String(id), "--repo", repo], spawnFn);
-    return;
-  }
-  const targetLabel = statusLabelFor(status);
-  for (const label of STATUS_LABELS) {
-    if (targetLabel !== null && label === targetLabel) {
-      continue;
-    }
-    try {
-      runGhVoid(bin, ["issue", "edit", String(id), "--repo", repo, "--remove-label", label], spawnFn);
-    } catch {}
-  }
-  if (targetLabel !== null) {
-    try {
-      runGhVoid(bin, ["issue", "edit", String(id), "--repo", repo, "--add-label", targetLabel], spawnFn);
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      if (!/not found/i.test(message)) {
-        throw error;
-      }
-      ensureStatusLabel(bin, repo, spawnFn, targetLabel);
-      runGhVoid(bin, ["issue", "edit", String(id), "--repo", repo, "--add-label", targetLabel], spawnFn);
-    }
-  }
-}
-function statusLabelFor(status) {
-  switch (status) {
-    case "in_progress":
-      return "in-progress";
-    case "blocked":
-      return "blocked";
-    case "ready":
-      return "ready";
-    case "under_review":
-      return "under-review";
-    case "failed":
-      return "failed";
-    case "cancelled":
-      return "cancelled";
-    case "open":
-      return null;
-    default:
-      throw new Error(`unsupported status: ${status}`);
-  }
-}
-function ensureStatusLabel(bin, repo, spawnFn, label) {
-  try {
-    runGhVoid(bin, [
-      "label",
-      "create",
-      label,
-      "--repo",
-      repo,
-      "--color",
-      "6f42c1",
-      "--description",
-      "Task status managed by Rig"
-    ], spawnFn);
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    if (!/already exists/i.test(message)) {
-      throw error;
-    }
-  }
-}
 function selectedGitHubEnv() {
-  const token = process.env.RIG_GITHUB_SELECTED_TOKEN?.trim() ?? "";
-  return { GH_TOKEN: token, GITHUB_TOKEN: token };
+  const token = process.env.RIG_GITHUB_SELECTED_TOKEN?.trim() || process.env.RIG_GITHUB_TOKEN?.trim() || "";
+  return { GH_TOKEN: token, GITHUB_TOKEN: token, RIG_GITHUB_TOKEN: token };
 }
 function ghSpawnOptions() {
   return { encoding: "utf-8", env: { ...process.env, ...selectedGitHubEnv() } };
@@ -3320,10 +3165,6 @@ function runGh(bin, args, spawnFn) {
   }
   return JSON.parse(res.stdout);
 }
-function runGhVoid(bin, args, spawnFn) {
-  const res = spawnFn(bin, [...args], ghSpawnOptions());
-  assertGhSuccess(args, res);
-}
 function assertGhSuccess(args, res) {
   if (res.error) {
     const msg = res.error.message ?? String(res.error);
@@ -3361,19 +3202,6 @@ function isPlainRecord2(candidate) {
 function hasRunnableTaskSource(source) {
   return Boolean(source && typeof source === "object" && !Array.isArray(source));
 }
-function cleanString(value) {
-  return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
-}
-function taskIdFromSourceIssueId(value) {
-  const raw = cleanString(value);
-  if (!raw)
-    return null;
-  const issueNumber = raw.match(/#([^#\s]+)$/)?.[1];
-  return issueNumber ?? raw;
-}
-function resolveSourceTaskId(taskId, sourceTask) {
-  return cleanString(sourceTask?.id) ?? taskIdFromSourceIssueId(sourceTask?.sourceIssueId) ?? taskIdFromSourceIssueId(sourceTask?.source_issue_id) ?? taskId;
-}
 async function getPluginTask(projectRoot, taskId) {
   const ctx = await buildPluginHostContext(projectRoot);
   const [source] = ctx?.taskSourceRegistry.list() ?? [];
@@ -3398,91 +3226,6 @@ async function readConfiguredTaskSourceTask(projectRoot, taskId) {
     task
   };
 }
-async function updatePluginTaskSourceTask(projectRoot, taskId, update) {
-  const ctx = await buildPluginHostContext(projectRoot);
-  const [source] = ctx?.taskSourceRegistry.list() ?? [];
-  if (!hasRunnableTaskSource(source)) {
-    return ctx ? { taskId, updated: false, source: "none", sourceKind: null, status: null } : null;
-  }
-  if (source.updateTask) {
-    await source.updateTask(taskId, update);
-  } else if (update.status && source.updateStatus) {
-    await source.updateStatus(taskId, update.status);
-  } else {
-    return {
-      taskId,
-      updated: false,
-      source: "plugin",
-      sourceKind: source.kind,
-      status: null
-    };
-  }
-  const status = source.get ? (await source.get(taskId))?.status ?? update.status ?? null : update.status ?? null;
-  return {
-    taskId,
-    updated: true,
-    source: "plugin",
-    sourceKind: source.kind,
-    status
-  };
-}
-async function updateConfiguredTaskSourceTask(projectRoot, input) {
-  const taskId = resolveSourceTaskId(input.taskId, input.sourceTask);
-  let pluginResult = null;
-  try {
-    pluginResult = await updatePluginTaskSourceTask(projectRoot, taskId, input.update);
-  } catch (error) {
-    const fallbackUpdated = updateSourceAwareTaskConfigTask(projectRoot, taskId, input.update, {
-      allowLocalTaskConfigStatusFallback: false
-    });
-    if (!fallbackUpdated) {
-      throw error;
-    }
-    return {
-      taskId,
-      updated: true,
-      source: "compat",
-      sourceKind: null,
-      status: await readSourceAwareTaskStatus(projectRoot, taskId)
-    };
-  }
-  if (pluginResult) {
-    return pluginResult;
-  }
-  const updated = updateSourceAwareTaskConfigTask(projectRoot, taskId, input.update);
-  return {
-    taskId,
-    updated,
-    source: updated ? "compat" : "none",
-    sourceKind: null,
-    status: await readSourceAwareTaskStatus(projectRoot, taskId)
-  };
-}
-function buildTaskRunLifecycleComment(input) {
-  const lines = [
-    "<!-- rig:status-comment -->",
-    `### Rig status: ${input.status}`,
-    "",
-    input.summary,
-    "",
-    `- Run: ${input.runId}`,
-    `- Status: ${input.status}`
-  ];
-  if (input.errorText?.trim()) {
-    lines.push(`- Error: ${input.errorText.trim()}`);
-  }
-  if (input.runtimeWorkspace?.trim()) {
-    lines.push(`- Runtime workspace: ${input.runtimeWorkspace.trim()}`);
-  }
-  if (input.logsDir?.trim()) {
-    lines.push(`- Logs: ${input.logsDir.trim()}`);
-  }
-  if (input.sessionDir?.trim()) {
-    lines.push(`- Session: ${input.sessionDir.trim()}`);
-  }
-  return lines.join(`
-`);
-}
 
 // packages/runtime/src/control-plane/native/task-state.ts
 import { existsSync as existsSync17, readFileSync as readFileSync8, readdirSync as readdirSync2, statSync as statSync4, writeFileSync as writeFileSync6 } from "fs";
@@ -5710,20 +5453,23 @@ function hashProjectPath(workspaceDir) {
 }
 function resolveGithubCliBinaryPath() {
   const explicit = process.env.RIG_GH_BIN?.trim();
-  if (explicit && existsSync23(explicit)) {
+  if (explicit && existsSync23(explicit) && !isRuntimeGatewayGhPath(explicit)) {
     return explicit;
   }
-  const bunResolved = Bun.which("gh");
-  if (bunResolved && existsSync23(bunResolved)) {
-    return bunResolved;
-  }
-  for (const candidate of ["/opt/homebrew/bin/gh", "/usr/local/bin/gh", "/usr/bin/gh"]) {
+  for (const candidate of ["/usr/bin/gh", "/opt/homebrew/bin/gh", "/usr/local/bin/gh"]) {
     if (existsSync23(candidate)) {
       return candidate;
     }
   }
+  const bunResolved = Bun.which("gh");
+  if (bunResolved && existsSync23(bunResolved) && !isRuntimeGatewayGhPath(bunResolved)) {
+    return bunResolved;
+  }
   return "";
 }
+function isRuntimeGatewayGhPath(candidate) {
+  return /\/\.rig\/bin\/gh$/.test(candidate.replace(/\\/g, "/"));
+}
 async function resolveGithubCliAuthToken(ghBinary = "") {
   const gh = ghBinary || resolveGithubCliBinaryPath();
   if (!gh) {
@@ -5824,6 +5570,8 @@ async function runtimeEnv(projectRoot, runtime) {
     XDG_CACHE_HOME: runtime.cacheDir,
     XDG_STATE_HOME: runtime.stateDir,
     RIG_AGENT_ID: runtime.id,
+    ...process.env.RIG_RUN_ID?.trim() ? { RIG_RUN_ID: process.env.RIG_RUN_ID.trim() } : {},
+    ...process.env.RIG_SERVER_RUN_ID?.trim() ? { RIG_SERVER_RUN_ID: process.env.RIG_SERVER_RUN_ID.trim() } : {},
     RIG_TASK_ID: runtime.taskId,
     RIG_TASK_RUNTIME_ID: runtime.id,
     RIG_TASK_WORKSPACE: runtime.workspaceDir,
@@ -5887,6 +5635,10 @@ async function runtimeEnv(projectRoot, runtime) {
       env[key] = value;
     }
   }
+  const rigGithubToken = process.env.RIG_GITHUB_TOKEN?.trim() || "";
+  if (rigGithubToken && !env.GITHUB_TOKEN && !env.GH_TOKEN) {
+    env.GITHUB_TOKEN = rigGithubToken;
+  }
   const fallbackGithubToken = !env.GITHUB_TOKEN && !env.GH_TOKEN ? await resolveGithubCliAuthToken(hostGhBinary) : "";
   if (fallbackGithubToken) {
     env.GITHUB_TOKEN = fallbackGithubToken;
@@ -5897,6 +5649,13 @@ async function runtimeEnv(projectRoot, runtime) {
   if (!env.GH_TOKEN && env.GITHUB_TOKEN) {
     env.GH_TOKEN = env.GITHUB_TOKEN;
   }
+  const gitHubToken = env.GITHUB_TOKEN || env.GH_TOKEN || rigGithubToken;
+  if (gitHubToken) {
+    env.RIG_GITHUB_TOKEN = gitHubToken;
+    env.GITHUB_TOKEN = env.GITHUB_TOKEN || gitHubToken;
+    env.GH_TOKEN = env.GH_TOKEN || gitHubToken;
+    applyGitHubCredentialHelperEnv(env);
+  }
   if (!env.GREPTILE_GITHUB_TOKEN && env.GITHUB_TOKEN) {
     env.GREPTILE_GITHUB_TOKEN = env.GITHUB_TOKEN;
   }
@@ -5977,12 +5736,21 @@ async function materializeRuntimeCertBundle(runtime) {
   }
   return targetPath;
 }
+function applyGitHubCredentialHelperEnv(env) {
+  env.GIT_TERMINAL_PROMPT = "0";
+  env.GIT_CONFIG_COUNT = "2";
+  env.GIT_CONFIG_KEY_0 = "credential.helper";
+  env.GIT_CONFIG_VALUE_0 = "";
+  env.GIT_CONFIG_KEY_1 = "credential.helper";
+  env.GIT_CONFIG_VALUE_1 = '!f() { test "$1" = get || exit 0; token="${GITHUB_TOKEN:-${GH_TOKEN:-${RIG_GITHUB_TOKEN:-}}}"; test -n "$token" || exit 0; echo username=x-access-token; echo password="$token"; }; f';
+}
 function persistRuntimeSecrets(runtimeRoot, env) {
   const secretsPath = resolve25(runtimeRoot, "runtime-secrets.json");
   const persisted = {};
   for (const key of [
     "GITHUB_TOKEN",
     "GH_TOKEN",
+    "RIG_GITHUB_TOKEN",
     "GREPTILE_GITHUB_TOKEN",
     "GREPTILE_API_KEY",
     "AI_REVIEW_MODE",
@@ -8461,7 +8229,11 @@ async function ensureAgentRuntime(options) {
   mkdirSync18(runtime.binDir, { recursive: true });
   mkdirSync18(workspaceLayout.distDir, { recursive: true });
   prepareRuntimeWorkspace(options.projectRoot, workspaceDir);
-  await resetEphemeralTaskArtifacts(workspaceDir, options.taskId);
+  if (options.preserveTaskArtifacts) {
+    console.log(`[rig-agent] Preserving runtime task artifacts for resume of ${options.taskId}.`);
+  } else {
+    await resetEphemeralTaskArtifacts(workspaceDir, options.taskId);
+  }
   const ctx = {
     runtimeId: options.id,
     taskId: options.taskId,
@@ -9173,7 +8945,8 @@ async function runAgentWrapper(options = {}) {
       taskId,
       mode: "worktree",
       provider,
-      taskRecordReader: taskRecordReaderFromEnv(taskId)
+      taskRecordReader: taskRecordReaderFromEnv(taskId),
+      preserveTaskArtifacts: process.env.RIG_RUN_RESUME === "1" || process.env.RIG_RUNTIME_ARTIFACT_CLEANUP === "preserve"
     });
     emitWrapperEvent("runtime.provision.completed", {
       runtimeId: runtime.id,
@@ -9278,15 +9051,13 @@ async function runAgentWrapper(options = {}) {
     throw error;
   }
   const serverManagedRun = Boolean(process.env.RIG_SERVER_RUN_ID?.trim());
-  if (exitCode === 0 && serverManagedRun) {
-    await updateTaskSourceAfterRun(monorepoRoot, taskId, runtime);
-  }
   const taskClosed = await isTaskClosed(monorepoRoot, taskId);
   const finalExitCode = resolveFinalProviderExitCode({
     providerExitCode: exitCode,
     taskClosed,
     serverManagedRun
   });
+  const handoffRequired = exitCode !== 0 || !taskClosed && !serverManagedRun;
   emitWrapperEvent("provider.completed", {
     provider,
     runtimeId: runtime.id,
@@ -9295,24 +9066,21 @@ async function runAgentWrapper(options = {}) {
     providerExitCode: exitCode,
     taskClosed,
     serverManagedRun,
-    handoffRequired: exitCode !== 0 || !taskClosed
+    handoffRequired
   });
-  if (exitCode !== 0 || !taskClosed) {
+  if (handoffRequired) {
     recordRuntimeHandoff(projectRoot, runtime, taskId, exitCode);
   }
-  if (exitCode === 0 && !taskClosed && serverManagedRun) {
-    console.error(`[rig-agent] Server-managed task run cannot finish successfully while ${taskId} is still open.`);
-  }
   return finalExitCode;
 }
 function resolveFinalProviderExitCode(input) {
   if (input.providerExitCode !== 0) {
     return input.providerExitCode;
   }
-  if (input.taskClosed) {
+  if (input.taskClosed || input.serverManagedRun) {
     return 0;
   }
-  return input.serverManagedRun ? 2 : 0;
+  return 0;
 }
 function shouldBypassProviderSandboxOnPlatform(provider, platform) {
   if (platform !== "darwin") {
@@ -9336,12 +9104,16 @@ function buildProviderArgs(provider, runtime, argv) {
   }
   if (provider === "pi") {
     const piArgs = [...argv];
+    const piProvider = cliOptionValue(piArgs, "--provider") || process.env.RIG_PI_PROVIDER?.trim() || "openai-codex";
     if (!hasCliOption(piArgs, "--provider")) {
-      piArgs.unshift(process.env.RIG_PI_PROVIDER?.trim() || "openai-codex");
+      piArgs.unshift(piProvider);
       piArgs.unshift("--provider");
     }
-    if (!hasCliOption(piArgs, "--model")) {
-      piArgs.unshift(process.env.RIG_PI_MODEL?.trim() || "gpt-5.5");
+    const model = cliOptionValue(piArgs, "--model") || process.env.RIG_PI_MODEL?.trim() || "gpt-5.5";
+    if (hasCliOption(piArgs, "--model")) {
+      rewriteCliOptionValue(piArgs, "--model", normalizePiModelForProvider(model, piProvider));
+    } else {
+      piArgs.unshift(normalizePiModelForProvider(model, piProvider));
       piArgs.unshift("--model");
     }
     return piArgs;
@@ -9409,6 +9181,38 @@ function resolveProvider() {
 function hasCliOption(argv, option) {
   return argv.some((arg) => arg === option || arg.startsWith(`${option}=`));
 }
+function cliOptionValue(argv, option) {
+  for (let index = 0;index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (arg === option) {
+      const next = argv[index + 1];
+      return next && !next.startsWith("--") ? next : undefined;
+    }
+    if (arg?.startsWith(`${option}=`)) {
+      return arg.slice(option.length + 1);
+    }
+  }
+  return;
+}
+function rewriteCliOptionValue(argv, option, value) {
+  for (let index = 0;index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (arg === option && argv[index + 1] && !argv[index + 1].startsWith("--")) {
+      argv[index + 1] = value;
+      return;
+    }
+    if (arg?.startsWith(`${option}=`)) {
+      argv[index] = `${option}=${value}`;
+      return;
+    }
+  }
+}
+function normalizePiModelForProvider(model, provider) {
+  if (provider === "openrouter" && model === "openai-codex/gpt-5.5") {
+    return "openai/gpt-5.5";
+  }
+  return model;
+}
 function providerBinary(provider) {
   if (provider === "codex") {
     return Bun.which("codex") || "codex";
@@ -9507,39 +9311,6 @@ async function readPluginTaskStatus(projectRoot, taskId) {
     return readSourceAwareTaskStatus(projectRoot, taskId);
   }
 }
-async function updateTaskSourceAfterRun(projectRoot, taskId, runtime) {
-  const comment = buildTaskRunLifecycleComment({
-    runId: process.env.RIG_SERVER_RUN_ID || "(unknown)",
-    status: "closed",
-    summary: "Rig task run completed and closed this task.",
-    runtimeWorkspace: runtime.workspaceDir,
-    logsDir: runtime.logsDir,
-    sessionDir: runtime.sessionDir
-  });
-  try {
-    const result = await updateConfiguredTaskSourceTask(projectRoot, {
-      taskId,
-      update: { status: "closed", comment }
-    });
-    if (result.updated) {
-      return;
-    }
-    throw new Error(result.source === "plugin" || result.sourceKind ? `configured task source${result.sourceKind ? ` (${result.sourceKind})` : ""} does not support lifecycle updates` : "no source-aware task source is configured");
-  } catch (error) {
-    let fallbackUpdated = false;
-    try {
-      fallbackUpdated = updateSourceAwareTaskConfigTask(projectRoot, taskId, { status: "closed", comment });
-    } catch (fallbackError) {
-      console.error(`[rig-agent] Source-aware compatibility update also failed for ${taskId}: ${fallbackError instanceof Error ? fallbackError.message : String(fallbackError)}`);
-    }
-    const message = `[rig-agent] Failed to update task source for ${taskId}${fallbackUpdated ? "; applied source-aware compatibility update" : ""}: ${error instanceof Error ? error.message : String(error)}`;
-    if (fallbackUpdated) {
-      console.log(message);
-    } else {
-      console.error(message);
-    }
-  }
-}
 function recordRuntimeHandoff(hostProjectRoot, runtime, taskId, exitCode) {
   const handoffDir = resolve35(hostProjectRoot, ".rig/runtime/handoffs");
   mkdirSync19(handoffDir, { recursive: true });