@h-rig/server 0.0.6-alpha.35 → 0.0.6-alpha.37

package/dist/src/server.js

@@ -4,7 +4,7 @@ var __require = import.meta.require;
 
 // packages/server/src/server.ts
 import { spawn as spawn5 } from "child_process";
-import { existsSync as existsSync19, readdirSync as readdirSync5, readFileSync as readFileSync14, statSync as statSync6 } from "fs";
+import { existsSync as existsSync20, readdirSync as readdirSync5, readFileSync as readFileSync15, statSync as statSync6 } from "fs";
 import { open } from "fs/promises";
 import { dirname as dirname20, resolve as resolve24 } from "path";
 import {
@@ -1206,6 +1206,7 @@ function resolveServerAuthorityPaths(projectRoot) {
 import { listAgentRuntimes } from "@rig/runtime/control-plane/runtime/isolation";
 
 // packages/server/src/server-helpers/snapshot-orchestrator.ts
+import { existsSync as existsSync4, readFileSync as readFileSync2 } from "fs";
 import { dirname as dirname7, resolve as resolve8 } from "path";
 import {
   listAuthorityRuns as listAuthorityRuns3,
@@ -1783,6 +1784,28 @@ function buildConversationSnapshot(projectRoot, options = {}) {
 }
 
 // packages/server/src/server-helpers/snapshot-orchestrator.ts
+function readPriorPrProgress(projectRoot, taskId) {
+  for (const candidate of [
+    resolve8(projectRoot, ".worktrees", taskId, "artifacts", taskId, "pr-state.json"),
+    resolve8(projectRoot, "artifacts", taskId, "pr-state.json")
+  ]) {
+    if (!existsSync4(candidate))
+      continue;
+    try {
+      const raw = JSON.parse(readFileSync2(candidate, "utf-8"));
+      const entries = Array.isArray(raw) ? raw : [raw];
+      const first = entries.find((entry) => entry && typeof entry === "object" && typeof entry.url === "string");
+      if (!first)
+        continue;
+      return [
+        `Prior progress exists for this task: PR ${first.url}${first.branch ? ` (branch ${first.branch})` : ""} was opened by an earlier run.`,
+        "Check its current state first (diff, checks, review). If the work is already complete and checks are green,",
+        "run `rig-agent completion-verification` to merge and close instead of re-implementing anything."
+      ].join(" ");
+    } catch {}
+  }
+  return null;
+}
 async function buildTaskPrompt(projectRoot, taskId, readers) {
   const task = (await readers.readWorkspaceTasks(projectRoot)).find((entry) => entry.id === taskId);
   if (!task) {
@@ -1800,6 +1823,7 @@ ${task.acceptanceCriteria}` : null,
     task.validation.length > 0 ? `Validation:
 - ${task.validation.join(`
 - `)}` : null,
+    readPriorPrProgress(projectRoot, String(task.id)),
     "Work directly in the assigned runtime workspace and leave the result in a reviewable state."
   ];
   return sections.filter((value) => Boolean(value)).join(`
@@ -1941,7 +1965,7 @@ async function buildEngineSnapshotPayload(inputs) {
 }
 
 // packages/server/src/server-helpers/plugin-host-cache.ts
-import { existsSync as existsSync4, statSync as statSync4 } from "fs";
+import { existsSync as existsSync5, statSync as statSync4 } from "fs";
 import { resolve as resolve9 } from "path";
 var contextCache = new Map;
 var taskListCache = new Map;
@@ -1949,7 +1973,7 @@ var DEFAULT_TASK_LIST_TTL_MS = 2000;
 function getPluginHostConfigMtime(projectRoot) {
   for (const name of ["rig.config.ts", "rig.config.json"]) {
     const path = resolve9(projectRoot, name);
-    if (existsSync4(path)) {
+    if (existsSync5(path)) {
       try {
         return statSync4(path).mtimeMs;
       } catch {
@@ -2243,7 +2267,7 @@ function createSnapshotService(options) {
 }
 
 // packages/server/src/server-helpers/task-projection.ts
-import { existsSync as existsSync5, mkdirSync as mkdirSync5, readFileSync as readFileSync2, writeFileSync as writeFileSync4 } from "fs";
+import { existsSync as existsSync6, mkdirSync as mkdirSync5, readFileSync as readFileSync3, writeFileSync as writeFileSync4 } from "fs";
 import { resolve as resolve10 } from "path";
 function projectionPath(projectRoot) {
   return resolve10(projectRoot, ".rig", "state", "task-projection.json");
@@ -2282,10 +2306,10 @@ function writeTaskProjection(projectRoot, input) {
 }
 function readTaskProjection(projectRoot) {
   const file = projectionPath(projectRoot);
-  if (!existsSync5(file))
+  if (!existsSync6(file))
     return null;
   try {
-    const parsed = JSON.parse(readFileSync2(file, "utf8"));
+    const parsed = JSON.parse(readFileSync3(file, "utf8"));
     return parsed && parsed.version === 1 && Array.isArray(parsed.tasks) ? parsed : null;
   } catch {
     return null;
@@ -3232,7 +3256,7 @@ function applyOrchestrationCommand(state, command) {
 // packages/server/src/server-helpers/run-mutations.ts
 import { spawn as spawn3 } from "child_process";
 import { loadConfig } from "@rig/core/load-config";
-import { existsSync as existsSync7, mkdirSync as mkdirSync7, readFileSync as readFileSync4, statSync as statSync5, writeFileSync as writeFileSync6 } from "fs";
+import { existsSync as existsSync8, mkdirSync as mkdirSync7, readFileSync as readFileSync5, statSync as statSync5, writeFileSync as writeFileSync6 } from "fs";
 import { dirname as dirname9, relative as relative2, resolve as resolve14 } from "path";
 import {
   listAuthorityRuns as listAuthorityRuns4,
@@ -3255,7 +3279,7 @@ import {
 // packages/server/src/scheduler.ts
 import { normalizeTaskLifecycleStatus } from "@rig/runtime/control-plane/state-sync/types";
 var TERMINAL_RUN_STATUSES = new Set(["done", "completed", "error", "failed", "stopped", "cancelled"]);
-var RUNNABLE_TASK_STATUSES = new Set(["draft", "open", "ready", "queued"]);
+var RUNNABLE_TASK_STATUSES = new Set(["draft", "open", "ready", "queued", "in_progress"]);
 var REMOTE_READY_STATUSES = new Set(["ready", "idle", "connected"]);
 function resolveLocalSchedulerWorkerCount(env = process.env) {
   const raw = env.RIG_SCHEDULER_LOCAL_WORKERS?.trim();
@@ -3362,7 +3386,7 @@ function summarizeRunValidationFailure(projectRoot, run) {
 
 // packages/server/src/server-helpers/github-auth-store.ts
 import { randomBytes } from "crypto";
-import { chmodSync, copyFileSync, existsSync as existsSync6, mkdirSync as mkdirSync6, readFileSync as readFileSync3, writeFileSync as writeFileSync5 } from "fs";
+import { chmodSync, copyFileSync, existsSync as existsSync7, mkdirSync as mkdirSync6, readFileSync as readFileSync4, writeFileSync as writeFileSync5 } from "fs";
 import { dirname as dirname8, resolve as resolve13 } from "path";
 function cleanString(value) {
   return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
@@ -3414,10 +3438,10 @@ function parsePendingDevices(value) {
   });
 }
 function readStoredAuth(stateFile) {
-  if (!existsSync6(stateFile))
+  if (!existsSync7(stateFile))
     return {};
   try {
-    const parsed = JSON.parse(readFileSync3(stateFile, "utf8"));
+    const parsed = JSON.parse(readFileSync4(stateFile, "utf8"));
     return {
       ...cleanString(parsed.token) ? { token: cleanString(parsed.token) } : {},
       login: cleanString(parsed.login),
@@ -3454,7 +3478,7 @@ function resolveGitHubAuthStateFile(projectRoot) {
 function copyGitHubAuthStateToLocalProjectRoot(stateFile, projectRoot) {
   const targetFile = localProjectAuthStateFile(projectRoot);
   mkdirSync6(dirname8(targetFile), { recursive: true });
-  if (existsSync6(stateFile)) {
+  if (existsSync7(stateFile)) {
     copyFileSync(stateFile, targetFile);
     try {
       chmodSync(targetFile, 384);
@@ -4483,7 +4507,7 @@ async function startLocalRun(state, runId, options) {
   broadcastSnapshotInvalidation(state);
   const cliProjectRoot = resolveLocalRunCliProjectRoot(state.projectRoot);
   const cliEntryPoint = resolve14(cliProjectRoot, "packages/cli/bin/rig.ts");
-  if (!existsSync7(cliEntryPoint)) {
+  if (!existsSync8(cliEntryPoint)) {
     const completedAt = new Date().toISOString();
     const failureSummary = `Rig task-run entrypoint missing at ${relative2(state.projectRoot, cliEntryPoint)}`;
     patchRunRecord(state.projectRoot, runId, {
@@ -4728,17 +4752,17 @@ function resolveLocalRunCliProjectRoot(projectRoot) {
     process.env.PROJECT_RIG_ROOT?.trim()
   ].filter((value) => !!value);
   for (const candidate of envCandidates) {
-    if (existsSync7(resolve14(candidate, "packages/cli/bin/rig.ts"))) {
+    if (existsSync8(resolve14(candidate, "packages/cli/bin/rig.ts"))) {
       return resolve14(candidate);
     }
   }
-  if (existsSync7(resolve14(projectRoot, "packages/cli/bin/rig.ts"))) {
+  if (existsSync8(resolve14(projectRoot, "packages/cli/bin/rig.ts"))) {
     return projectRoot;
   }
   try {
     const monorepoRoot = resolveMonorepoRoot3(projectRoot);
     const outerProjectRoot = dirname9(dirname9(monorepoRoot));
-    if (existsSync7(resolve14(outerProjectRoot, "packages/cli/bin/rig.ts"))) {
+    if (existsSync8(resolve14(outerProjectRoot, "packages/cli/bin/rig.ts"))) {
       return outerProjectRoot;
     }
   } catch {}
@@ -4778,7 +4802,7 @@ function appendRunMessage(projectRoot, input) {
     throw new Error(`Run not found: ${input.runId}`);
   }
   const timelinePath = resolve14(resolveAuthorityRunDir3(projectRoot, input.runId), "timeline.jsonl");
-  const existingLines = fileExists(timelinePath) ? readFileSync4(timelinePath, "utf8").trim() : "";
+  const existingLines = fileExists(timelinePath) ? readFileSync5(timelinePath, "utf8").trim() : "";
   const nextLine = JSON.stringify({
     id: input.messageId,
     type: "user_message",
@@ -4898,10 +4922,14 @@ function recoverStaleLocalRun(projectRoot, run) {
   if (hasLiveRecordedProcess && serverPid === process.pid)
     return false;
   const completedAt = new Date().toISOString();
+  const taskId = normalizeString(record.taskId);
+  if (taskId) {
+    enqueueTaskState(projectRoot, taskId, 0);
+  }
   patchRunRecord(projectRoot, run.runId, {
     status: "failed",
     completedAt,
-    errorText: `Recovered stale local run ${run.runId} after server startup; no active server-owned process was tracking it.`
+    errorText: taskId ? `Recovered stale local run ${run.runId} after server startup; no active server-owned process was tracking it. Task ${taskId} was re-queued for automatic restart.` : `Recovered stale local run ${run.runId} after server startup; no active server-owned process was tracking it.`
   });
   return true;
 }
@@ -5023,7 +5051,7 @@ async function reconcileScheduler(state, reason) {
 import { randomUUID } from "crypto";
 import { spawnSync as spawnSync3 } from "child_process";
 import { basename, dirname as dirname15, isAbsolute as isAbsolute4, resolve as resolve20 } from "path";
-import { copyFileSync as copyFileSync2, existsSync as existsSync13, mkdirSync as mkdirSync13, readFileSync as readFileSync9, writeFileSync as writeFileSync12 } from "fs";
+import { copyFileSync as copyFileSync2, existsSync as existsSync14, mkdirSync as mkdirSync13, readFileSync as readFileSync10, writeFileSync as writeFileSync12 } from "fs";
 import {
   listAuthorityRuns as listAuthorityRuns5,
   readAuthorityRun as readAuthorityRun7,
@@ -5102,16 +5130,16 @@ function tokenFromRef(ref) {
 
 // packages/server/src/server-helpers/run-steering.ts
 import { dirname as dirname10, resolve as resolve15 } from "path";
-import { existsSync as existsSync8, mkdirSync as mkdirSync8, readFileSync as readFileSync5 } from "fs";
+import { existsSync as existsSync9, mkdirSync as mkdirSync8, readFileSync as readFileSync6 } from "fs";
 import { appendJsonlRecord as appendJsonlRecord2, readAuthorityRun as readAuthorityRun6, resolveAuthorityRunDir as resolveAuthorityRunDir4 } from "@rig/runtime/control-plane/authority-files";
 var steeringSequence = 0;
 function runSteeringPath(projectRoot, runId) {
   return resolve15(resolveAuthorityRunDir4(projectRoot, runId), "steering.jsonl");
 }
 function readJsonl(path) {
-  if (!existsSync8(path))
+  if (!existsSync9(path))
     return [];
-  return readFileSync5(path, "utf8").split(/\r?\n/).map((line) => line.trim()).filter(Boolean).flatMap((line) => {
+  return readFileSync6(path, "utf8").split(/\r?\n/).map((line) => line.trim()).filter(Boolean).flatMap((line) => {
     try {
       const value = JSON.parse(line);
       return value && typeof value === "object" && !Array.isArray(value) ? [value] : [];
@@ -5226,11 +5254,11 @@ import {
 } from "@rig/runtime/control-plane/tasks/source-lifecycle";
 
 // packages/server/src/server-helpers/github-api-session-index.ts
-import { chmodSync as chmodSync3, existsSync as existsSync10, mkdirSync as mkdirSync10, readFileSync as readFileSync7, writeFileSync as writeFileSync9 } from "fs";
+import { chmodSync as chmodSync3, existsSync as existsSync11, mkdirSync as mkdirSync10, readFileSync as readFileSync8, writeFileSync as writeFileSync9 } from "fs";
 import { dirname as dirname12, resolve as resolve17 } from "path";
 
 // packages/server/src/server-helpers/github-user-namespace.ts
-import { chmodSync as chmodSync2, existsSync as existsSync9, mkdirSync as mkdirSync9, readFileSync as readFileSync6, writeFileSync as writeFileSync8 } from "fs";
+import { chmodSync as chmodSync2, existsSync as existsSync10, mkdirSync as mkdirSync9, readFileSync as readFileSync7, writeFileSync as writeFileSync8 } from "fs";
 import { dirname as dirname11, isAbsolute as isAbsolute2, relative as relative3, resolve as resolve16 } from "path";
 function cleanString3(value) {
   return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
@@ -5297,10 +5325,10 @@ function isPathInsideNamespace(namespaceRoot, candidatePath) {
 function writeRemoteUserNamespaceMetadata(namespace) {
   mkdirSync9(namespace.stateDir, { recursive: true });
   const previous = (() => {
-    if (!existsSync9(namespace.metadataFile))
+    if (!existsSync10(namespace.metadataFile))
       return null;
     try {
-      const parsed = JSON.parse(readFileSync6(namespace.metadataFile, "utf8"));
+      const parsed = JSON.parse(readFileSync7(namespace.metadataFile, "utf8"));
       return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
     } catch {
       return null;
@@ -5357,10 +5385,10 @@ function parseEntry(value) {
   };
 }
 function readIndex(indexFile) {
-  if (!existsSync10(indexFile))
+  if (!existsSync11(indexFile))
     return [];
   try {
-    const parsed = JSON.parse(readFileSync7(indexFile, "utf8"));
+    const parsed = JSON.parse(readFileSync8(indexFile, "utf8"));
     return Array.isArray(parsed.sessions) ? parsed.sessions.flatMap((entry) => {
       const parsedEntry = parseEntry(entry);
       return parsedEntry ? [parsedEntry] : [];
@@ -5509,7 +5537,7 @@ function inspectorAgentLifecycleSnapshot(input) {
 // packages/server/src/server-helpers/project-registry.ts
 import { createHash as createHash2 } from "crypto";
 import { spawnSync as spawnSync2 } from "child_process";
-import { existsSync as existsSync11, mkdirSync as mkdirSync11, readFileSync as readFileSync8, readdirSync as readdirSync3, writeFileSync as writeFileSync10 } from "fs";
+import { existsSync as existsSync12, mkdirSync as mkdirSync11, readFileSync as readFileSync9, readdirSync as readdirSync3, writeFileSync as writeFileSync10 } from "fs";
 import { dirname as dirname13, resolve as resolve18 } from "path";
 function normalizeRepoSlug(value) {
   const trimmed = value.trim();
@@ -5520,10 +5548,10 @@ function registryPath(projectRoot) {
 }
 function readRegistry(projectRoot) {
   const path = registryPath(projectRoot);
-  if (!existsSync11(path))
+  if (!existsSync12(path))
     return {};
   try {
-    const payload = JSON.parse(readFileSync8(path, "utf8"));
+    const payload = JSON.parse(readFileSync9(path, "utf8"));
     if (!payload || typeof payload !== "object" || Array.isArray(payload))
       return {};
     const projects = payload.projects;
@@ -5541,7 +5569,7 @@ function writeRegistry(projectRoot, projects) {
 function resolveConfigPath(projectRoot) {
   for (const name of ["rig.config.ts", "rig.config.mts", "rig.config.json"]) {
     const path = resolve18(projectRoot, name);
-    if (existsSync11(path))
+    if (existsSync12(path))
       return path;
   }
   return null;
@@ -5550,7 +5578,7 @@ function hashFile(path) {
   if (!path)
     return null;
   try {
-    return createHash2("sha256").update(readFileSync8(path)).digest("hex");
+    return createHash2("sha256").update(readFileSync9(path)).digest("hex");
   } catch {
     return null;
   }
@@ -5570,7 +5598,7 @@ function buildRunSummary(projectRoot) {
   try {
     const runs = readdirSync3(runsDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).flatMap((entry) => {
       try {
-        const run = JSON.parse(readFileSync8(resolve18(runsDir, entry.name, "run.json"), "utf8"));
+        const run = JSON.parse(readFileSync9(resolve18(runsDir, entry.name, "run.json"), "utf8"));
         return [{ runId: typeof run.runId === "string" ? run.runId : entry.name, status: typeof run.status === "string" ? run.status : "unknown", updatedAt: typeof run.updatedAt === "string" ? run.updatedAt : "" }];
       } catch {
         return [];
@@ -5628,7 +5656,7 @@ function projectRegistryContainsCheckout(projectRoot, checkoutPath) {
 }
 
 // packages/server/src/server-helpers/remote-checkout.ts
-import { existsSync as existsSync12, mkdirSync as mkdirSync12, writeFileSync as writeFileSync11 } from "fs";
+import { existsSync as existsSync13, mkdirSync as mkdirSync12, writeFileSync as writeFileSync11 } from "fs";
 import { dirname as dirname14, isAbsolute as isAbsolute3, relative as relative4, resolve as resolve19 } from "path";
 function safeSlugSegments(repoSlug) {
   const segments = repoSlug.split("/").map((part) => part.trim()).filter(Boolean);
@@ -5727,7 +5755,7 @@ function gitCredentialConfig(token) {
   };
 }
 async function prepareRemoteCheckout(input) {
-  const exists = input.exists ?? existsSync12;
+  const exists = input.exists ?? existsSync13;
   const strategy = input.strategy;
   if (strategy.kind === "uploaded-snapshot") {
     return extractUploadedSnapshotArchive({
@@ -5775,9 +5803,9 @@ function buildServerControlStatus() {
   };
 }
 function buildProjectConfigStatus(root) {
-  const hasConfigTs = existsSync13(resolve20(root, "rig.config.ts"));
-  const hasConfigJson = existsSync13(resolve20(root, "rig.config.json"));
-  const hasLegacyTaskConfig = existsSync13(resolve20(root, ".rig", "task-config.json"));
+  const hasConfigTs = existsSync14(resolve20(root, "rig.config.ts"));
+  const hasConfigJson = existsSync14(resolve20(root, "rig.config.json"));
+  const hasLegacyTaskConfig = existsSync14(resolve20(root, ".rig", "task-config.json"));
   let kind = "missing";
   if (hasConfigTs)
     kind = "rig-config-ts";
@@ -5895,11 +5923,11 @@ function backupCheckoutFile(checkoutPath, relativePath) {
 }
 function parsePackageJsonLosslessly(checkoutPath) {
   const packagePath = resolve20(checkoutPath, "package.json");
-  if (!existsSync13(packagePath)) {
+  if (!existsSync14(packagePath)) {
     return { existed: false, packageJson: { name: basename(checkoutPath) || "rig-project", private: true } };
   }
   try {
-    const parsed = JSON.parse(readFileSync9(packagePath, "utf8"));
+    const parsed = JSON.parse(readFileSync10(packagePath, "utf8"));
     return {
       existed: true,
       packageJson: parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : { name: basename(checkoutPath) || "rig-project", private: true }
@@ -5913,9 +5941,9 @@ function parsePackageJsonLosslessly(checkoutPath) {
   }
 }
 function ensureRemoteCheckoutRigPackageDeps(checkoutPath) {
-  const hasConfig = ["rig.config.ts", "rig.config.mts", "rig.config.json"].some((name) => existsSync13(resolve20(checkoutPath, name)));
+  const hasConfig = ["rig.config.ts", "rig.config.mts", "rig.config.json"].some((name) => existsSync14(resolve20(checkoutPath, name)));
   const packagePath = resolve20(checkoutPath, "package.json");
-  if (!hasConfig && !existsSync13(packagePath)) {
+  if (!hasConfig && !existsSync14(packagePath)) {
     return { skipped: true, reason: "package.json and rig.config missing" };
   }
   const parsed = parsePackageJsonLosslessly(checkoutPath);
@@ -5961,10 +5989,10 @@ function configLooksStructurallyUsable(source) {
 }
 function ensureRemoteCheckoutRigConfig(checkoutPath, repoSlug, reason = "missing or incomplete rig config") {
   const configPath = resolve20(checkoutPath, "rig.config.ts");
-  const existingConfigName = ["rig.config.ts", "rig.config.mts", "rig.config.json"].find((name) => existsSync13(resolve20(checkoutPath, name)));
+  const existingConfigName = ["rig.config.ts", "rig.config.mts", "rig.config.json"].find((name) => existsSync14(resolve20(checkoutPath, name)));
   if (existingConfigName) {
     const existingPath = resolve20(checkoutPath, existingConfigName);
-    const source = readFileSync9(existingPath, "utf8");
+    const source = readFileSync10(existingPath, "utf8");
     if (existingConfigName !== "rig.config.json" && configLooksStructurallyUsable(source)) {
       return { path: existingPath, changed: false, reason: "config structurally complete" };
     }
@@ -5987,7 +6015,7 @@ function ensureRemoteCheckoutRigConfig(checkoutPath, repoSlug, reason = "missing
   };
 }
 function validateRemoteCheckoutRigConfig(checkoutPath) {
-  const configFile = ["rig.config.ts", "rig.config.mts", "rig.config.json"].find((name) => existsSync13(resolve20(checkoutPath, name)));
+  const configFile = ["rig.config.ts", "rig.config.mts", "rig.config.json"].find((name) => existsSync14(resolve20(checkoutPath, name)));
   if (!configFile)
     return { ok: false, error: "missing rig config" };
   if (process.env.RIG_TEST_SKIP_REMOTE_CHECKOUT_INSTALL === "1") {
@@ -6009,7 +6037,7 @@ function validateRemoteCheckoutRigConfig(checkoutPath) {
   return { ok: true, configFile };
 }
 function installRemoteCheckoutPackages(checkoutPath) {
-  if (!existsSync13(resolve20(checkoutPath, "package.json"))) {
+  if (!existsSync14(resolve20(checkoutPath, "package.json"))) {
     return { skipped: true, reason: "package.json missing" };
   }
   if (process.env.RIG_TEST_SKIP_REMOTE_CHECKOUT_INSTALL === "1") {
@@ -6022,8 +6050,8 @@ function installRemoteCheckoutPackages(checkoutPath) {
   return { ok: true, command: "bun install", stdout: result.stdout?.trim() || undefined };
 }
 function repairRemoteCheckoutForRig(checkoutPath, repoSlug) {
-  const hasConfig = ["rig.config.ts", "rig.config.mts", "rig.config.json"].some((name) => existsSync13(resolve20(checkoutPath, name)));
-  const hasPackage = existsSync13(resolve20(checkoutPath, "package.json"));
+  const hasConfig = ["rig.config.ts", "rig.config.mts", "rig.config.json"].some((name) => existsSync14(resolve20(checkoutPath, name)));
+  const hasPackage = existsSync14(resolve20(checkoutPath, "package.json"));
   if (!hasConfig && !hasPackage) {
     return {
       packageJson: { skipped: true, reason: "package.json and rig.config missing" },
@@ -6123,24 +6151,24 @@ function readGitHeadCommit(projectRoot) {
   try {
     let gitDir = resolve20(projectRoot, ".git");
     try {
-      const dotGit = readFileSync9(gitDir, "utf8").trim();
+      const dotGit = readFileSync10(gitDir, "utf8").trim();
       const gitDirPrefix = "gitdir:";
       if (dotGit.startsWith(gitDirPrefix)) {
         gitDir = resolve20(projectRoot, dotGit.slice(gitDirPrefix.length).trim());
       }
     } catch {}
-    const head = readFileSync9(resolve20(gitDir, "HEAD"), "utf8").trim();
+    const head = readFileSync10(resolve20(gitDir, "HEAD"), "utf8").trim();
     const refPrefix = "ref:";
     if (!head.startsWith(refPrefix)) {
       return normalizeCommit(head);
     }
     const ref = head.slice(refPrefix.length).trim();
     const refPath = resolve20(gitDir, ref);
-    if (existsSync13(refPath)) {
-      return normalizeCommit(readFileSync9(refPath, "utf8").trim());
+    if (existsSync14(refPath)) {
+      return normalizeCommit(readFileSync10(refPath, "utf8").trim());
     }
-    const commonDir = normalizeString(readFileSync9(resolve20(gitDir, "commondir"), "utf8"));
-    return commonDir ? normalizeCommit(readFileSync9(resolve20(gitDir, commonDir, ref), "utf8").trim()) : null;
+    const commonDir = normalizeString(readFileSync10(resolve20(gitDir, "commondir"), "utf8"));
+    return commonDir ? normalizeCommit(readFileSync10(resolve20(gitDir, commonDir, ref), "utf8").trim()) : null;
   } catch {
     return null;
   }
@@ -6437,7 +6465,7 @@ function saveGitHubTokenForRemoteUser(input) {
   const apiSession = store.createApiSession();
   registerGitHubApiSession({ projectRoot: input.projectRoot, token: apiSession.token, namespace, selectedRepo: input.selectedRepo });
   const requestedRoot = normalizeString(input.requestedProjectRoot);
-  if (requestedRoot && isAbsolute4(requestedRoot) && existsSync13(resolve20(requestedRoot))) {
+  if (requestedRoot && isAbsolute4(requestedRoot) && existsSync14(resolve20(requestedRoot))) {
     copyGitHubAuthStateToLocalProjectRoot(namespace.authStateFile, resolve20(requestedRoot));
   }
   if (shouldWriteRootAuthCompat(input.projectRoot)) {
@@ -6475,7 +6503,7 @@ function resolveRequestedProjectRoot(currentRoot, rawRoot) {
     throw new Error("projectRoot must be an absolute path on the Rig server host");
   }
   const normalizedRoot = resolve20(requestedRoot);
-  if (!existsSync13(normalizedRoot)) {
+  if (!existsSync14(normalizedRoot)) {
     throw new Error("projectRoot does not exist on the Rig server host");
   }
   return normalizedRoot;
@@ -7367,7 +7395,7 @@ data: ${JSON.stringify({ connectedAt: new Date().toISOString() })}
             return deps.badRequest("projectRoot must be an absolute path on the Rig server host");
           }
           const normalizedRoot = resolve20(requestedRoot);
-          const exists = existsSync13(normalizedRoot);
+          const exists = existsSync14(normalizedRoot);
           if (exists && requestAuth.userNamespace) {
             const allowedByNamespace = isPathInsideNamespace(requestAuth.userNamespace.root, normalizedRoot);
             const allowedByRegistry = projectRegistryContainsCheckout(requestAuth.userNamespace.root, normalizedRoot);
@@ -7397,7 +7425,7 @@ data: ${JSON.stringify({ connectedAt: new Date().toISOString() })}
               message: "Requested project root does not exist on the Rig server host."
             }, 404);
           }
-          if (!existsSync13(resolve20(normalizedRoot, "rig.config.ts")) && !existsSync13(resolve20(normalizedRoot, "rig.config.json"))) {
+          if (!existsSync14(resolve20(normalizedRoot, "rig.config.ts")) && !existsSync14(resolve20(normalizedRoot, "rig.config.json"))) {
             return deps.jsonResponse({
               ok: false,
               projectRoot: state.projectRoot,
@@ -7615,8 +7643,8 @@ data: ${JSON.stringify({ connectedAt: new Date().toISOString() })}
             ok: true,
             projectRoot: targetRoot,
             configPath,
-            exists: existsSync13(configPath),
-            requiresOverwrite: existsSync13(configPath),
+            exists: existsSync14(configPath),
+            requiresOverwrite: existsSync14(configPath),
             source,
             owner,
             repo,
@@ -7653,7 +7681,7 @@ data: ${JSON.stringify({ connectedAt: new Date().toISOString() })}
             githubUserId: authStatus.userId ?? authStatus.login
           });
           const configPath = resolve20(targetRoot, "rig.config.ts");
-          if (existsSync13(configPath) && !overwrite) {
+          if (existsSync14(configPath) && !overwrite) {
             return deps.jsonResponse({
               ok: false,
               error: "rig.config.ts already exists. Confirm overwrite to replace it; Rig will create a backup first.",
@@ -7669,7 +7697,7 @@ data: ${JSON.stringify({ connectedAt: new Date().toISOString() })}
             return deps.jsonResponse({ ok: false, error: repoProbe.message, repoProbe }, 400);
           }
           let backupPath = null;
-          if (existsSync13(configPath)) {
+          if (existsSync14(configPath)) {
             backupPath = backupConfigPath(configPath);
             copyFileSync2(configPath, backupPath);
           }
@@ -7959,7 +7987,7 @@ data: ${JSON.stringify({ connectedAt: new Date().toISOString() })}
         }
         if (url.pathname === "/api/pi-rig/install" && req.method === "POST") {
           const configuredPackageSource = normalizeString(process.env.RIG_PI_RIG_PACKAGE_SOURCE);
-          const packageSource = configuredPackageSource ?? [process.env.RIG_HOST_PROJECT_ROOT, process.cwd(), state.projectRoot].map((root) => normalizeString(root)).filter((root) => Boolean(root)).map((root) => resolve20(root, "packages", "pi-rig")).find((candidate) => existsSync13(resolve20(candidate, "package.json"))) ?? "npm:@h-rig/pi-rig";
+          const packageSource = configuredPackageSource ?? [process.env.RIG_HOST_PROJECT_ROOT, process.cwd(), state.projectRoot].map((root) => normalizeString(root)).filter((root) => Boolean(root)).map((root) => resolve20(root, "packages", "pi-rig")).find((candidate) => existsSync14(resolve20(candidate, "package.json"))) ?? "npm:@h-rig/pi-rig";
           if (process.env.RIG_TEST_FAKE_PI_INSTALL === "1") {
             return deps.jsonResponse({ ok: true, installed: true, piOk: true, piRigOk: true, extensionPath: "remote:~/.pi/agent/extensions/pi-rig", packageSource });
           }
@@ -8506,7 +8534,7 @@ data: ${JSON.stringify({ connectedAt: new Date().toISOString() })}
           } catch {
             return deps.badRequest("Invalid artifact path");
           }
-          if (!existsSync13(artifactPath)) {
+          if (!existsSync14(artifactPath)) {
             return deps.notFound();
           }
           return new Response(Bun.file(artifactPath));
@@ -8576,8 +8604,6 @@ data: ${JSON.stringify({ connectedAt: new Date().toISOString() })}
               return `${sessionPath}/shell`;
             if (action === "commands/run" && req.method === "POST")
               return `${sessionPath}/commands/run`;
-            if (action === "commands/respond" && req.method === "POST")
-              return `${sessionPath}/commands/respond`;
             if (action === "extension-ui/respond" && req.method === "POST")
               return `${sessionPath}/extension-ui/respond`;
             if (action === "abort" && req.method === "POST")
@@ -9450,7 +9476,7 @@ async function routeWebSocketRequest(state, deps, request) {
 }
 
 // packages/server/src/server-helpers/inspector-jobs.ts
-import { existsSync as existsSync17, mkdirSync as mkdirSync16, readFileSync as readFileSync12, writeFileSync as writeFileSync15 } from "fs";
+import { existsSync as existsSync18, mkdirSync as mkdirSync16, readFileSync as readFileSync13, writeFileSync as writeFileSync15 } from "fs";
 import { dirname as dirname18, resolve as resolve23 } from "path";
 import { readJsonFile as readJsonFile3 } from "@rig/runtime/control-plane/authority-files";
 import { resolveMonorepoRoot as resolveMonorepoRoot5 } from "@rig/runtime/control-plane/native/utils";
@@ -9559,7 +9585,7 @@ import { randomUUID as randomUUID3 } from "crypto";
 
 // packages/server/src/inspector/mission.ts
 import { randomUUID as randomUUID2 } from "crypto";
-import { appendFileSync, existsSync as existsSync14, mkdirSync as mkdirSync14, readFileSync as readFileSync10, readdirSync as readdirSync4, renameSync, writeFileSync as writeFileSync13 } from "fs";
+import { appendFileSync, existsSync as existsSync15, mkdirSync as mkdirSync14, readFileSync as readFileSync11, readdirSync as readdirSync4, renameSync, writeFileSync as writeFileSync13 } from "fs";
 import { dirname as dirname16, join, resolve as resolve21 } from "path";
 function isJsonValue(value) {
   if (value === null)
@@ -9600,7 +9626,7 @@ function isRecord2(value) {
 }
 function readJsonRecord(path) {
   try {
-    const parsed = JSON.parse(readFileSync10(path, "utf8"));
+    const parsed = JSON.parse(readFileSync11(path, "utf8"));
     if (!isRecord2(parsed)) {
       return { ok: false, error: `Mission file ${path} does not contain an object` };
     }
@@ -9713,9 +9739,9 @@ function createInspectorMissionController(options) {
   }
   function listMissionJournal(missionId) {
     const path = journalPath(missionId);
-    if (!existsSync14(path))
+    if (!existsSync15(path))
       return [];
-    return readFileSync10(path, "utf8").split(`
+    return readFileSync11(path, "utf8").split(`
 `).filter((line) => line.trim().length > 0).map((line) => JSON.parse(line)).filter(isRecord2).map((entry) => ({
       id: typeof entry.id === "string" ? entry.id : `journal:${randomUUID2()}`,
       missionId,
@@ -9731,7 +9757,7 @@ function createInspectorMissionController(options) {
   }
   function readMissionOnly(missionId) {
     const path = missionPath(missionId);
-    if (!existsSync14(path)) {
+    if (!existsSync15(path)) {
       return { ok: false, error: `Mission ${missionId} was not found` };
     }
     const read = readJsonRecord(path);
@@ -9782,7 +9808,7 @@ function createInspectorMissionController(options) {
       const source = cloneJsonRecord(input.sourceTask);
       const missionId = nextId();
       const path = missionPath(missionId);
-      if (existsSync14(path)) {
+      if (existsSync15(path)) {
         const existing = readMissionOnly(missionId);
         if (!existing.ok)
           return existing;
@@ -12289,7 +12315,7 @@ function createGlobalInspectorService(options) {
 
 // packages/server/src/inspector/upstream-sync.ts
 import { spawnSync as spawnSync4 } from "child_process";
-import { existsSync as existsSync15, mkdirSync as mkdirSync15, readFileSync as readFileSync11, writeFileSync as writeFileSync14 } from "fs";
+import { existsSync as existsSync16, mkdirSync as mkdirSync15, readFileSync as readFileSync12, writeFileSync as writeFileSync14 } from "fs";
 import { dirname as dirname17, resolve as resolve22 } from "path";
 import { resolveMonorepoRoot as resolveMonorepoRoot4 } from "@rig/runtime/control-plane/native/utils";
 var UPSTREAM_VALIDATION_DESCRIPTIONS = {
@@ -12434,11 +12460,11 @@ function upstreamStatePath(projectRoot, override) {
 }
 function readUpstreamState(projectRoot, statePath) {
   const path = upstreamStatePath(projectRoot, statePath);
-  if (!existsSync15(path)) {
+  if (!existsSync16(path)) {
     return null;
   }
   try {
-    return JSON.parse(readFileSync11(path, "utf-8"));
+    return JSON.parse(readFileSync12(path, "utf-8"));
   } catch {
     return null;
   }
@@ -12452,10 +12478,10 @@ function writeUpstreamState(projectRoot, state, statePath) {
 function readImportedRevision(projectRoot, upstreamsDocPath) {
   const monorepoRoot = resolveMonorepoRoot4(projectRoot);
   const docPath = upstreamsDocPath ? resolve22(upstreamsDocPath) : resolve22(monorepoRoot, "docs", "UPSTREAMS.md");
-  if (!existsSync15(docPath)) {
+  if (!existsSync16(docPath)) {
     throw new Error(`UPSTREAMS.md not found at ${docPath}`);
   }
-  const docContent = readFileSync11(docPath, "utf-8");
+  const docContent = readFileSync12(docPath, "utf-8");
   const revision = parseImportedUpstreamRevision(docContent, "upstream") ?? parseImportedUpstreamRevision(docContent, "humoongate");
   if (!revision) {
     throw new Error(`Failed to parse upstream imported revision from ${docPath}`);
@@ -12477,7 +12503,7 @@ function resolveRemoteBranch(repoRoot, remote, gitRunner) {
   return null;
 }
 function isGitCheckout(path, gitRunner) {
-  if (!existsSync15(resolve22(path, ".git"))) {
+  if (!existsSync16(resolve22(path, ".git"))) {
     return false;
   }
   const result = gitRunner(path, ["rev-parse", "--is-inside-work-tree"]);
@@ -12727,10 +12753,10 @@ async function runUpstreamSyncScan(options) {
 }
 
 // packages/server/src/server-helpers/task-config.ts
-import { existsSync as existsSync16 } from "fs";
+import { existsSync as existsSync17 } from "fs";
 async function readTaskConfig(projectRoot) {
   const taskConfigPath = resolveRigServerPaths(projectRoot).taskConfigPath;
-  if (!existsSync16(taskConfigPath)) {
+  if (!existsSync17(taskConfigPath)) {
     return {};
   }
   try {
@@ -12789,7 +12815,7 @@ async function createInspectorFollowupTask(projectRoot, input) {
   const sourceKey = normalizeString(input.sourceKey) ?? normalizeString(input.details?.sourceKey);
   const createdAt = normalizeString(input.createdAt) ?? new Date().toISOString();
   const status = normalizeTaskLifecycleStatus2(normalizeString(input.status) ?? "open") ?? "open";
-  const existingIssueLines = existsSync17(issuesPath) ? readFileSync12(issuesPath, "utf8").split(/\r?\n/).map((line) => line.trim()).filter(Boolean) : [];
+  const existingIssueLines = existsSync18(issuesPath) ? readFileSync13(issuesPath, "utf8").split(/\r?\n/).map((line) => line.trim()).filter(Boolean) : [];
   const existingIssues = existingIssueLines.map((line) => {
     try {
       return JSON.parse(line);
@@ -12798,7 +12824,7 @@ async function createInspectorFollowupTask(projectRoot, input) {
     }
   }).filter((value) => value !== null);
   const existingIds = new Set(existingIssues.map((issue) => typeof issue.id === "string" ? issue.id : null).filter((value) => value !== null));
-  const rawTaskState = existsSync17(taskStatePath) ? readJsonFile3(taskStatePath, {}) : {};
+  const rawTaskState = existsSync18(taskStatePath) ? readJsonFile3(taskStatePath, {}) : {};
   const tasks = rawTaskState.tasks && typeof rawTaskState.tasks === "object" && !Array.isArray(rawTaskState.tasks) ? rawTaskState.tasks : {};
   const existingTaskIdFromSourceKey = sourceKey == null ? null : Object.entries(tasks).find(([, metadata]) => {
     if (!metadata || typeof metadata !== "object" || Array.isArray(metadata)) {
@@ -13169,10 +13195,10 @@ function isAuthorizedLinearWebhookRequest(req) {
 }
 
 // packages/server/src/server-helpers/notifications.ts
-import { existsSync as existsSync18, mkdirSync as mkdirSync17, readFileSync as readFileSync13 } from "fs";
+import { existsSync as existsSync19, mkdirSync as mkdirSync17, readFileSync as readFileSync14 } from "fs";
 import { dirname as dirname19 } from "path";
 async function loadNotificationConfig(path) {
-  if (!existsSync18(path)) {
+  if (!existsSync19(path)) {
     const defaultConfig = { targets: [] };
     mkdirSync17(dirname19(path), { recursive: true });
     await Bun.write(path, `${JSON.stringify(defaultConfig, null, 2)}
@@ -13189,10 +13215,10 @@ async function loadNotificationConfig(path) {
   }
 }
 function readRecentEvents(file, limit) {
-  if (!existsSync18(file)) {
+  if (!existsSync19(file)) {
     return [];
   }
-  const lines = readFileSync13(file, "utf-8").split(/\r?\n/).map((line) => line.trim()).filter(Boolean).slice(-limit);
+  const lines = readFileSync14(file, "utf-8").split(/\r?\n/).map((line) => line.trim()).filter(Boolean).slice(-limit);
   const events = [];
   for (const line of lines) {
     try {
@@ -13288,10 +13314,10 @@ function extractObjectLiteralBlock(source, property) {
 function readFallbackIssueAnalysisConfig(projectRoot) {
   for (const fileName of ["rig.config.ts", "rig.config.json"]) {
     const path = resolve24(projectRoot, fileName);
-    if (!existsSync19(path))
+    if (!existsSync20(path))
       continue;
     try {
-      const source = readFileSync14(path, "utf8");
+      const source = readFileSync15(path, "utf8");
       if (fileName.endsWith(".json"))
         return JSON.parse(source);
       const issueBlock = extractObjectLiteralBlock(source, "issueAnalysis");
@@ -13463,7 +13489,7 @@ async function withServerAuthorityEnvIfNeeded(projectRoot, fn) {
 async function readWorkspaceTasks(projectRoot) {
   const issuesPath = resolve24(resolveMonorepoRoot6(projectRoot), ".beads", "issues.jsonl");
   const taskConfig = await readTaskConfig(projectRoot);
-  if (!existsSync19(issuesPath)) {
+  if (!existsSync20(issuesPath)) {
     return [];
   }
   const latestById = new Map;
@@ -13555,7 +13581,7 @@ async function listArtifactSummaries(projectRoot, taskId, knownTaskIds, knownRun
     }
   }
   return taskIds.flatMap((currentTaskId) => {
-    const currentRoot = resolveTaskArtifactDirsFromRuns(projectRoot, currentTaskId, runs).find((path) => existsSync19(path));
+    const currentRoot = resolveTaskArtifactDirsFromRuns(projectRoot, currentTaskId, runs).find((path) => existsSync20(path));
     if (!currentRoot) {
       return [];
     }
@@ -13610,7 +13636,7 @@ function buildInspectorStreamPayload(state, sequence) {
 }
 function listRemoteRunArtifacts(projectRoot, runId) {
   const root = remoteArtifactsRoot(projectRoot, runId);
-  if (!existsSync19(root)) {
+  if (!existsSync20(root)) {
     return [];
   }
   return readdirSync5(root, { withFileTypes: true }).filter((entry) => entry.isFile()).filter((entry) => !entry.name.endsWith(".json")).map((entry) => {
@@ -13908,10 +13934,10 @@ function startRunFileWatcher(state, pollMs) {
   }, Math.max(250, Math.min(pollMs, 1000)));
 }
 function startPoller(state, pollMs) {
-  let offset = existsSync19(state.eventsFile) ? statSync6(state.eventsFile).size : 0;
+  let offset = existsSync20(state.eventsFile) ? statSync6(state.eventsFile).size : 0;
   return setInterval(async () => {
     try {
-      if (!existsSync19(state.eventsFile)) {
+      if (!existsSync20(state.eventsFile)) {
         return;
       }
       const file = await open(state.eventsFile, "r");