@h-rig/server 0.0.6-alpha.1 → 0.0.6-alpha.10

package/dist/src/server-helpers/issue-analysis.js

@@ -1,6 +1,5 @@
 // @bun
 // packages/server/src/server-helpers/issue-analysis.ts
-import { execFile } from "child_process";
 import { createHash } from "crypto";
 function stableIssueHash(issue) {
   const labels = Array.isArray(issue.labels) ? [...issue.labels].map(String).sort() : [];
@@ -134,16 +133,33 @@ function parseIssueAnalysisResult(raw) {
   return result;
 }
 function createDefaultPiIssueAnalysisCommandRunner() {
-  return (command, args, options) => new Promise((resolve) => {
-    execFile(command, [...args], {
-      timeout: options.timeoutMs,
-      maxBuffer: 10 * 1024 * 1024,
-      env: options.env ? { ...process.env, ...options.env } : process.env
-    }, (error, stdout, stderr) => {
-      const exitCode = typeof error?.code === "number" ? error.code : error ? 1 : 0;
-      resolve({ exitCode, stdout: String(stdout ?? ""), stderr: String(stderr ?? "") });
+  return async (command, args, options) => {
+    const env = options.env ? { ...process.env, ...options.env } : process.env;
+    const proc = Bun.spawn([command, ...args], {
+      stdout: "pipe",
+      stderr: "pipe",
+      env
     });
-  });
+    let timedOut = false;
+    const timer = setTimeout(() => {
+      timedOut = true;
+      proc.kill();
+    }, options.timeoutMs);
+    try {
+      const [stdout, stderr, exitCode] = await Promise.all([
+        new Response(proc.stdout).text(),
+        new Response(proc.stderr).text(),
+        proc.exited
+      ]);
+      return {
+        exitCode: timedOut && exitCode === 0 ? 1 : exitCode,
+        stdout,
+        stderr: timedOut && stderr.trim().length === 0 ? `Pi issue analysis timed out after ${options.timeoutMs}ms` : stderr
+      };
+    } finally {
+      clearTimeout(timer);
+    }
+  };
 }
 function createPiIssueAnalyzer(input = {}) {
   const piBinary = input.piBinary ?? process.env.RIG_ISSUE_ANALYSIS_PI_BINARY ?? "pi";
@@ -151,7 +167,10 @@ function createPiIssueAnalyzer(input = {}) {
   const runCommand = input.runCommand ?? createDefaultPiIssueAnalysisCommandRunner();
   return async ({ prompt }) => {
     const args = ["--print", "--mode", "json", "--no-session"];
-    const model = input.model?.trim() || process.env.RIG_ISSUE_ANALYSIS_MODEL?.trim() || "openai-codex/gpt-5.5";
+    const provider = input.provider?.trim() || process.env.RIG_ISSUE_ANALYSIS_PROVIDER?.trim() || process.env.RIG_PI_PROVIDER?.trim();
+    const model = input.model?.trim() || process.env.RIG_ISSUE_ANALYSIS_MODEL?.trim() || process.env.RIG_PI_MODEL?.trim() || "openai-codex/gpt-5.5";
+    if (provider)
+      args.push("--provider", provider);
     if (model)
       args.push("--model", model);
     args.push(prompt);

package/dist/src/server-helpers/run-mutations.js

@@ -2,8 +2,8 @@
 // packages/server/src/server-helpers/run-mutations.ts
 import { spawn } from "child_process";
 import { loadConfig } from "@rig/core/load-config";
-import { existsSync as existsSync6, mkdirSync as mkdirSync5, readFileSync as readFileSync3, statSync as statSync3, writeFileSync as writeFileSync5 } from "fs";
-import { dirname as dirname5, relative as relative2, resolve as resolve9 } from "path";
+import { existsSync as existsSync7, mkdirSync as mkdirSync6, readFileSync as readFileSync4, statSync as statSync3, writeFileSync as writeFileSync6 } from "fs";
+import { dirname as dirname5, relative as relative2, resolve as resolve10 } from "path";
 import {
   listAuthorityRuns as listAuthorityRuns7,
   readAuthorityRun as readAuthorityRun8,
@@ -98,8 +98,8 @@ function normalizeStatus(value) {
 }
 
 // packages/server/src/server.ts
-import { existsSync as existsSync5, readdirSync, readFileSync as readFileSync2, statSync as statSync2 } from "fs";
-import { dirname as dirname4, resolve as resolve7 } from "path";
+import { existsSync as existsSync6, readdirSync, readFileSync as readFileSync3, statSync as statSync2 } from "fs";
+import { dirname as dirname4, resolve as resolve8 } from "path";
 import {
   listAuthorityArtifactRoots,
   listAuthorityRuns as listAuthorityRuns6,
@@ -295,6 +295,24 @@ var snapshotCache = new Map;
 var contextCache = new Map;
 var taskListCache = new Map;
 
+// packages/server/src/server-helpers/task-projection.ts
+import { existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync, writeFileSync as writeFileSync3 } from "fs";
+import { resolve as resolve5 } from "path";
+function projectionPath(projectRoot) {
+  return resolve5(projectRoot, ".rig", "state", "task-projection.json");
+}
+function readTaskProjection(projectRoot) {
+  const file = projectionPath(projectRoot);
+  if (!existsSync3(file))
+    return null;
+  try {
+    const parsed = JSON.parse(readFileSync(file, "utf8"));
+    return parsed && parsed.version === 1 && Array.isArray(parsed.tasks) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
 // packages/server/src/server-helpers/terminal-runtime.ts
 import { WS_CHANNELS as WS_CHANNELS2 } from "@rig/contracts";
 
@@ -302,7 +320,7 @@ import { WS_CHANNELS as WS_CHANNELS2 } from "@rig/contracts";
 import { RIG_WS_CHANNELS } from "@rig/contracts";
 
 // packages/server/src/server-helpers/run-writers.ts
-import { resolve as resolve5 } from "path";
+import { resolve as resolve6 } from "path";
 import {
   appendJsonlRecord,
   readAuthorityRun as readAuthorityRun3,
@@ -327,7 +345,7 @@ function patchRunRecord(projectRoot, runId, patch) {
     ...patch,
     updatedAt: normalizeString(patch.updatedAt) ?? new Date().toISOString()
   };
-  writeJsonFile2(resolve5(resolveAuthorityRunDir2(projectRoot, runId), "run.json"), next);
+  writeJsonFile2(resolve6(resolveAuthorityRunDir2(projectRoot, runId), "run.json"), next);
   return next;
 }
 function buildRunStartPatch(startedAt) {
@@ -459,8 +477,9 @@ import {
 } from "@rig/runtime/control-plane/tasks/source-lifecycle";
 
 // packages/server/src/server-helpers/github-auth-store.ts
-import { chmodSync, existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync, writeFileSync as writeFileSync3 } from "fs";
-import { resolve as resolve6 } from "path";
+import { randomBytes } from "crypto";
+import { chmodSync, existsSync as existsSync4, mkdirSync as mkdirSync4, readFileSync as readFileSync2, writeFileSync as writeFileSync4 } from "fs";
+import { resolve as resolve7 } from "path";
 function cleanString(value) {
   return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
 }
@@ -472,11 +491,29 @@ function cleanScopes(value) {
     return clean ? [clean] : [];
   });
 }
+function parseApiSessions(value) {
+  if (!Array.isArray(value))
+    return [];
+  return value.flatMap((entry) => {
+    if (!entry || typeof entry !== "object" || Array.isArray(entry))
+      return [];
+    const record = entry;
+    const token = cleanString(record.token);
+    if (!token)
+      return [];
+    return [{
+      token,
+      login: cleanString(record.login),
+      userId: cleanString(record.userId),
+      createdAt: cleanString(record.createdAt) ?? undefined
+    }];
+  });
+}
 function readStoredAuth(stateFile) {
-  if (!existsSync3(stateFile))
+  if (!existsSync4(stateFile))
     return {};
   try {
-    const parsed = JSON.parse(readFileSync(stateFile, "utf8"));
+    const parsed = JSON.parse(readFileSync2(stateFile, "utf8"));
     return {
       ...cleanString(parsed.token) ? { token: cleanString(parsed.token) } : {},
       login: cleanString(parsed.login),
@@ -485,6 +522,7 @@ function readStoredAuth(stateFile) {
       selectedRepo: cleanString(parsed.selectedRepo),
       tokenSource: parsed.tokenSource === "oauth-device" || parsed.tokenSource === "manual-token" || parsed.tokenSource === "env" ? parsed.tokenSource : undefined,
       pendingDevice: parsePendingDevice(parsed.pendingDevice),
+      apiSessions: parseApiSessions(parsed.apiSessions),
       updatedAt: cleanString(parsed.updatedAt) ?? undefined
     };
   } catch {
@@ -503,16 +541,19 @@ function parsePendingDevice(value) {
     return null;
   return { pollId, deviceCode, expiresAt, intervalSeconds };
 }
+function newApiSessionToken() {
+  return `rig_${randomBytes(32).toString("base64url")}`;
+}
 function writeStoredAuth(stateFile, payload) {
-  mkdirSync3(resolve6(stateFile, ".."), { recursive: true });
-  writeFileSync3(stateFile, `${JSON.stringify(payload, null, 2)}
+  mkdirSync4(resolve7(stateFile, ".."), { recursive: true });
+  writeFileSync4(stateFile, `${JSON.stringify(payload, null, 2)}
 `, { encoding: "utf8", mode: 384 });
   try {
     chmodSync(stateFile, 384);
   } catch {}
 }
 function resolveGitHubAuthStateFile(projectRoot) {
-  return resolve6(resolveServerAuthorityPaths(projectRoot).stateDir, "github-auth.json");
+  return resolve7(resolveServerAuthorityPaths(projectRoot).stateDir, "github-auth.json");
 }
 function createGitHubAuthStore(projectRoot) {
   const stateFile = resolveGitHubAuthStateFile(projectRoot);
@@ -545,9 +586,38 @@ function createGitHubAuthStore(projectRoot) {
         scopes: input.scopes ?? [],
         selectedRepo: input.selectedRepo ?? previous.selectedRepo ?? null,
         pendingDevice: null,
+        apiSessions: previous.apiSessions ?? [],
         updatedAt: new Date().toISOString()
       });
     },
+    createApiSession() {
+      const previous = readStoredAuth(stateFile);
+      const token = newApiSessionToken();
+      const session = {
+        token,
+        login: cleanString(previous.login),
+        userId: cleanString(previous.userId),
+        createdAt: new Date().toISOString()
+      };
+      writeStoredAuth(stateFile, {
+        ...previous,
+        apiSessions: [...(previous.apiSessions ?? []).slice(-9), session],
+        updatedAt: new Date().toISOString()
+      });
+      return { token, login: session.login ?? null, userId: session.userId ?? null };
+    },
+    readApiSession(token) {
+      const clean = cleanString(token);
+      if (!clean)
+        return null;
+      const previous = readStoredAuth(stateFile);
+      const session = (previous.apiSessions ?? []).find((candidate) => candidate.token === clean);
+      return session ? { login: cleanString(session.login), userId: cleanString(session.userId) } : null;
+    },
+    copyToProjectRoot(projectRoot2) {
+      const targetFile = resolveGitHubAuthStateFile(projectRoot2);
+      writeStoredAuth(targetFile, readStoredAuth(stateFile));
+    },
     savePendingDevice(input) {
       const previous = readStoredAuth(stateFile);
       writeStoredAuth(stateFile, {
@@ -775,10 +845,10 @@ function extractGitHubIssueNodeId(task) {
 }
 
 // packages/server/src/server-helpers/http-router.ts
-var RIG_CONFIG_PACKAGE_VERSION = "0.0.6-alpha.1";
+var RIG_CONFIG_PACKAGE_DIST_TAG = "latest";
 var RIG_CONFIG_DEV_DEPENDENCIES = {
-  "@rig/core": `npm:@h-rig/core@${RIG_CONFIG_PACKAGE_VERSION}`,
-  "@rig/standard-plugin": `npm:@h-rig/standard-plugin@${RIG_CONFIG_PACKAGE_VERSION}`
+  "@rig/core": `npm:@h-rig/core@${RIG_CONFIG_PACKAGE_DIST_TAG}`,
+  "@rig/standard-plugin": `npm:@h-rig/standard-plugin@${RIG_CONFIG_PACKAGE_DIST_TAG}`
 };
 
 // packages/server/src/server-helpers/ws-router.ts
@@ -917,10 +987,10 @@ var CLUSTERS = {
 };
 
 // packages/server/src/server-helpers/task-config.ts
-import { existsSync as existsSync4 } from "fs";
+import { existsSync as existsSync5 } from "fs";
 async function readTaskConfig(projectRoot) {
   const taskConfigPath = resolveRigServerPaths(projectRoot).taskConfigPath;
-  if (!existsSync4(taskConfigPath)) {
+  if (!existsSync5(taskConfigPath)) {
     return {};
   }
   try {
@@ -937,8 +1007,8 @@ var serverPathEnvQueue = Promise.resolve();
 async function withServerPathEnv(projectRoot, fn) {
   const waitForTurn = serverPathEnvQueue;
   let releaseTurn;
-  serverPathEnvQueue = new Promise((resolve8) => {
-    releaseTurn = resolve8;
+  serverPathEnvQueue = new Promise((resolve9) => {
+    releaseTurn = resolve9;
   });
   await waitForTurn;
   const paths = resolveServerAuthorityPaths(projectRoot);
@@ -974,9 +1044,9 @@ async function withServerAuthorityEnvIfNeeded(projectRoot, fn) {
   return withServerPathEnv(projectRoot, fn);
 }
 async function readWorkspaceTasks(projectRoot) {
-  const issuesPath = resolve7(resolveMonorepoRoot5(projectRoot), ".beads", "issues.jsonl");
+  const issuesPath = resolve8(resolveMonorepoRoot5(projectRoot), ".beads", "issues.jsonl");
   const taskConfig = await readTaskConfig(projectRoot);
-  if (!existsSync5(issuesPath)) {
+  if (!existsSync6(issuesPath)) {
     return [];
   }
   const latestById = new Map;
@@ -995,7 +1065,7 @@ async function readWorkspaceTasks(projectRoot) {
       description: normalizeString(entry.description),
       acceptanceCriteria: normalizeString(entry.acceptance_criteria),
       status: normalizedStatus ?? "unknown",
-      sourceStatus: normalizedStatus ? null : rawStatus,
+      sourceStatus: normalizedStatus && rawStatus !== normalizedStatus ? rawStatus : normalizedStatus ? null : rawStatus,
       priority: typeof entry.priority === "number" ? entry.priority : typeof entry.priority === "string" ? Number(entry.priority) : null,
       issueType: normalizeString(entry.issue_type),
       role: normalizeString(config.role) ?? null,
@@ -1022,7 +1092,7 @@ async function readWorkspaceTasks(projectRoot) {
 if (false) {}
 
 // packages/server/src/server-helpers/validation-failure.ts
-import { resolve as resolve8 } from "path";
+import { resolve as resolve9 } from "path";
 import {
   readJsonFile as readJsonFile4,
   resolveTaskArtifactDirs
@@ -1036,7 +1106,7 @@ function summarizeRunValidationFailure(projectRoot, run) {
       continue;
     }
     seen.add(artifactRoot);
-    const summary = readJsonFile4(resolve8(artifactRoot, "validation-summary.json"), null);
+    const summary = readJsonFile4(resolve9(artifactRoot, "validation-summary.json"), null);
     if (!summary || summary.status !== "fail") {
       continue;
     }
@@ -1120,15 +1190,36 @@ async function syncProjectStatusForRunLifecycle(projectRoot, run, status, config
   if (!run.taskId)
     return;
   const issueNodeId = extractGitHubIssueNodeId(runSourceTaskIdentity(run));
-  await syncGitHubProjectStatusForTaskUpdate({
-    taskId: run.taskId,
-    status,
-    issueNodeId,
-    token: createGitHubAuthStore(projectRoot).readToken(),
-    config
-  }).catch(() => {
-    return;
-  });
+  try {
+    const result = await syncGitHubProjectStatusForTaskUpdate({
+      taskId: run.taskId,
+      status,
+      issueNodeId,
+      token: createGitHubAuthStore(projectRoot).readToken(),
+      config
+    });
+    if (!result.synced && result.reason !== "project-sync-disabled") {
+      appendRunLogEntry(projectRoot, run.runId, {
+        id: `log:${run.runId}:github-project-sync:${status}`,
+        title: "GitHub Project sync skipped",
+        detail: `Project status sync for ${run.taskId} could not run: ${result.reason}.`,
+        tone: "warn",
+        status: "running",
+        createdAt: new Date().toISOString(),
+        payload: { reason: result.reason, issueNodeId }
+      });
+    }
+  } catch (error) {
+    appendRunLogEntry(projectRoot, run.runId, {
+      id: `log:${run.runId}:github-project-sync-error:${status}`,
+      title: "GitHub Project sync failed",
+      detail: error instanceof Error ? error.message : String(error),
+      tone: "error",
+      status: "running",
+      createdAt: new Date().toISOString(),
+      payload: { issueNodeId }
+    });
+  }
 }
 async function autoAssignRunIssue(projectRoot, run) {
   if (!run.taskId)
@@ -1230,11 +1321,23 @@ function assertNoActiveRunForTask(projectRoot, taskId, newRunId) {
     return;
   throw new Error(`Task ${taskId} already has an active Rig run: ${existing.runId}`);
 }
+async function resolveSourceTaskForRun(projectRoot, taskId, readTasks) {
+  const fromReader = (await readTasks(projectRoot)).find((task) => task.id === taskId) ?? null;
+  if (fromReader)
+    return fromReader;
+  const projected = readTaskProjection(projectRoot)?.tasks.find((task) => String(task.id) === taskId) ?? null;
+  if (projected)
+    return projected;
+  if (readTasks !== readWorkspaceTasks) {
+    return (await readWorkspaceTasks(projectRoot)).find((task) => task.id === taskId) ?? null;
+  }
+  return null;
+}
 async function createRunRecord(projectRoot, input, readTasks = readWorkspaceTasks) {
   if ("taskId" in input && input.taskId) {
     assertNoActiveRunForTask(projectRoot, input.taskId, input.runId);
   }
-  const sourceTask = "taskId" in input && input.taskId ? (await readTasks(projectRoot)).find((task) => task.id === input.taskId) ?? null : null;
+  const sourceTask = "taskId" in input && input.taskId ? await resolveSourceTaskForRun(projectRoot, input.taskId, readTasks) : null;
   const taskTitle = sourceTask?.title ?? ("taskId" in input && input.taskId ? input.taskId : null);
   const runDir = resolveAuthorityRunDir4(projectRoot, input.runId);
   const runRecord = {
@@ -1268,11 +1371,11 @@ async function createRunRecord(projectRoot, input, readTasks = readWorkspaceTask
     initiatedBy: input.initiatedBy ?? null,
     ...sourceTask ? { sourceTask: sourceTaskContract(sourceTask) } : {}
   };
-  mkdirSync5(runDir, { recursive: true });
-  writeFileSync5(resolve9(runDir, "run.json"), `${JSON.stringify(runRecord, null, 2)}
+  mkdirSync6(runDir, { recursive: true });
+  writeFileSync6(resolve10(runDir, "run.json"), `${JSON.stringify(runRecord, null, 2)}
 `, "utf8");
   if ("initialPrompt" in input && input.initialPrompt && input.initialPrompt.trim().length > 0) {
-    writeFileSync5(resolve9(runDir, "timeline.jsonl"), `${JSON.stringify({
+    writeFileSync6(resolve10(runDir, "timeline.jsonl"), `${JSON.stringify({
       id: `message-${Date.now()}`,
       type: "user_message",
       text: input.initialPrompt,
@@ -1306,6 +1409,7 @@ async function startLocalRun(state, runId, options) {
     throw new Error(`Run not found: ${runId}`);
   }
   const startedAt = new Date().toISOString();
+  const resumeMode = options?.resume === true;
   state.runProcesses.set(runId, {
     runId,
     child: null,
@@ -1322,9 +1426,9 @@ async function startLocalRun(state, runId, options) {
     summary: run.title
   });
   appendRunLogEntry(state.projectRoot, runId, {
-    id: `log:${runId}:prepare`,
-    title: "Rig task run starting",
-    detail: run.taskId ?? run.title,
+    id: `log:${runId}:${resumeMode ? "resume" : "prepare"}`,
+    title: resumeMode ? "Rig task run resuming" : "Rig task run starting",
+    detail: resumeMode ? `Resuming ${run.taskId ?? run.title ?? runId} after server restart or operator resume.` : run.taskId ?? run.title,
     tone: "info",
     status: "preparing",
     createdAt: startedAt
@@ -1332,8 +1436,8 @@ async function startLocalRun(state, runId, options) {
   broadcastRunLogAppended(state, runId, readLatestRawRunLog(state.projectRoot, runId));
   broadcastSnapshotInvalidation(state);
   const cliProjectRoot = resolveLocalRunCliProjectRoot(state.projectRoot);
-  const cliEntryPoint = resolve9(cliProjectRoot, "packages/cli/bin/rig.ts");
-  if (!existsSync6(cliEntryPoint)) {
+  const cliEntryPoint = resolve10(cliProjectRoot, "packages/cli/bin/rig.ts");
+  if (!existsSync7(cliEntryPoint)) {
     const completedAt = new Date().toISOString();
     const failureSummary = `Rig task-run entrypoint missing at ${relative2(state.projectRoot, cliEntryPoint)}`;
     patchRunRecord(state.projectRoot, runId, {
@@ -1402,7 +1506,15 @@ async function startLocalRun(state, runId, options) {
           RIG_SERVER_INTERNAL_EXEC: "1",
           ...serverUrl ? { RIG_SERVER_URL: serverUrl } : {},
           ...bridgeAuthToken ? { RIG_AUTH_TOKEN: bridgeAuthToken } : {},
-          ...bridgeGitHubToken ? { RIG_GITHUB_TOKEN: bridgeGitHubToken } : {}
+          ...bridgeGitHubToken ? {
+            RIG_GITHUB_TOKEN: bridgeGitHubToken,
+            GITHUB_TOKEN: bridgeGitHubToken,
+            GH_TOKEN: bridgeGitHubToken
+          } : {},
+          ...resumeMode ? {
+            RIG_RUN_RESUME: "1",
+            RIG_RUNTIME_ARTIFACT_CLEANUP: "preserve"
+          } : {}
         },
         stdio: ["ignore", "pipe", "pipe"]
       });
@@ -1442,9 +1554,9 @@ async function startLocalRun(state, runId, options) {
         handleRunProcessOutput(Buffer.isBuffer(data) ? data.toString("utf8") : String(data), "error", "Rig task run stderr");
       });
       try {
-        const exit = await new Promise((resolve10) => {
-          child.once("error", (error) => resolve10({ code: 1, signal: null, error }));
-          child.once("close", (code, signal) => resolve10({ code, signal }));
+        const exit = await new Promise((resolve11) => {
+          child.once("error", (error) => resolve11({ code: 1, signal: null, error }));
+          child.once("close", (code, signal) => resolve11({ code, signal }));
         });
         if (exit.error) {
           throw new Error(`Failed to start task run: ${exit.error.message}`);
@@ -1544,17 +1656,17 @@ function resolveLocalRunCliProjectRoot(projectRoot) {
     process.env.PROJECT_RIG_ROOT?.trim()
   ].filter((value) => !!value);
   for (const candidate of envCandidates) {
-    if (existsSync6(resolve9(candidate, "packages/cli/bin/rig.ts"))) {
-      return resolve9(candidate);
+    if (existsSync7(resolve10(candidate, "packages/cli/bin/rig.ts"))) {
+      return resolve10(candidate);
     }
   }
-  if (existsSync6(resolve9(projectRoot, "packages/cli/bin/rig.ts"))) {
+  if (existsSync7(resolve10(projectRoot, "packages/cli/bin/rig.ts"))) {
     return projectRoot;
   }
   try {
     const monorepoRoot = resolveMonorepoRoot6(projectRoot);
     const outerProjectRoot = dirname5(dirname5(monorepoRoot));
-    if (existsSync6(resolve9(outerProjectRoot, "packages/cli/bin/rig.ts"))) {
+    if (existsSync7(resolve10(outerProjectRoot, "packages/cli/bin/rig.ts"))) {
       return outerProjectRoot;
     }
   } catch {}
@@ -1574,15 +1686,15 @@ async function resumeRunRecord(state, input) {
   if (run.status === "completed") {
     throw new Error("Completed runs cannot be resumed.");
   }
-  await startLocalRun(state, input.runId, { promptOverride: input.promptOverride ?? null });
+  await startLocalRun(state, input.runId, { promptOverride: input.promptOverride ?? null, resume: input.restart !== true });
 }
 function appendRunMessage(projectRoot, input) {
   const run = readAuthorityRun8(projectRoot, input.runId);
   if (!run) {
     throw new Error(`Run not found: ${input.runId}`);
   }
-  const timelinePath = resolve9(resolveAuthorityRunDir4(projectRoot, input.runId), "timeline.jsonl");
-  const existingLines = fileExists(timelinePath) ? readFileSync3(timelinePath, "utf8").trim() : "";
+  const timelinePath = resolve10(resolveAuthorityRunDir4(projectRoot, input.runId), "timeline.jsonl");
+  const existingLines = fileExists(timelinePath) ? readFileSync4(timelinePath, "utf8").trim() : "";
   const nextLine = JSON.stringify({
     id: input.messageId,
     type: "user_message",
@@ -1590,11 +1702,11 @@ function appendRunMessage(projectRoot, input) {
     attachments: input.attachments ?? [],
     createdAt: input.createdAt
   });
-  writeFileSync5(timelinePath, existingLines.length > 0 ? `${existingLines}
+  writeFileSync6(timelinePath, existingLines.length > 0 ? `${existingLines}
 ${nextLine}
 ` : `${nextLine}
 `, "utf8");
-  writeJsonFile4(resolve9(resolveAuthorityRunDir4(projectRoot, input.runId), "run.json"), {
+  writeJsonFile4(resolve10(resolveAuthorityRunDir4(projectRoot, input.runId), "run.json"), {
     ...run,
     updatedAt: input.createdAt
   });
@@ -1620,7 +1732,7 @@ async function stopRunRecord(stateOrProjectRoot, input) {
     completedAt: run.completedAt ?? input.createdAt,
     updatedAt: input.createdAt
   };
-  writeJsonFile4(resolve9(resolveAuthorityRunDir4(projectRoot, input.runId), "run.json"), nextRun);
+  writeJsonFile4(resolve10(resolveAuthorityRunDir4(projectRoot, input.runId), "run.json"), nextRun);
   if (run.status !== "completed" && run.taskId) {
     const taskId = run.taskId;
     (async () => {
@@ -1658,34 +1770,12 @@ function removeTaskIdsFromQueueState2(projectRoot, taskIds) {
   writeQueueState(projectRoot, next);
   return next;
 }
-var ORPHANABLE_LOCAL_RUN_STATUSES = new Set(["preparing", "running"]);
-function reconcileOrphanedLocalRuns(state, runs, nowIso) {
-  let changed = false;
-  for (const run of runs) {
+var RESUMABLE_LOCAL_RUN_STATUSES = new Set(["created", "preparing", "running", "validating", "reviewing"]);
+function collectResumableLocalRuns(state, runs) {
+  return runs.filter((run) => {
     const status = normalizeString(run.status)?.toLowerCase() ?? "";
-    const serverPid = run.serverPid;
-    const wasStartedByRigServer = typeof serverPid === "number" || typeof serverPid === "string";
-    if (run.mode !== "local" || !wasStartedByRigServer || !ORPHANABLE_LOCAL_RUN_STATUSES.has(status) || state.runProcesses.has(run.runId)) {
-      continue;
-    }
-    const detail = "Recovered stale local run after Rig server restart; no live child process was attached to this server instance.";
-    patchRunRecord(state.projectRoot, run.runId, {
-      status: "failed",
-      completedAt: run.completedAt ?? nowIso,
-      updatedAt: nowIso,
-      errorText: detail
-    });
-    appendRunLogEntry(state.projectRoot, run.runId, {
-      id: `log:${run.runId}:stale-local-run`,
-      title: "Run marked stale after server restart",
-      detail,
-      tone: "error",
-      status: "failed",
-      createdAt: nowIso
-    });
-    changed = true;
-  }
-  return changed;
+    return run.mode === "local" && RESUMABLE_LOCAL_RUN_STATUSES.has(status) && !state.runProcesses.has(run.runId);
+  });
 }
 async function reconcileScheduler(state, reason) {
   if (state.scheduler.reconciling) {
@@ -1700,7 +1790,20 @@ async function reconcileScheduler(state, reason) {
         const queue = readQueueState(state.projectRoot);
         const tasks = await state.snapshotService.getWorkspaceTasks();
         let runs = listAuthorityRuns7(state.projectRoot);
-        let changed = reconcileOrphanedLocalRuns(state, runs, new Date().toISOString());
+        let changed = false;
+        const resumableRuns = collectResumableLocalRuns(state, runs);
+        for (const run of resumableRuns) {
+          appendRunLogEntry(state.projectRoot, run.runId, {
+            id: `log:${run.runId}:auto-resume:${Date.now()}`,
+            title: "Run auto-resume scheduled",
+            detail: `Rig server recovered nonterminal run ${run.runId} after ${reason}; resuming the same lifecycle instead of restarting it.`,
+            tone: "info",
+            status: "preparing",
+            createdAt: new Date().toISOString()
+          });
+          await startLocalRun(state, run.runId, { resume: true });
+          changed = true;
+        }
         if (changed) {
           runs = listAuthorityRuns7(state.projectRoot);
         }

package/dist/src/server-helpers/snapshot-orchestrator.js

@@ -699,7 +699,7 @@ async function buildRigSnapshotPayload(projectRoot, readers) {
   const taskSummaries = (await readers.readWorkspaceTasks(projectRoot)).map((task) => ({
     ...toTaskSummary(workspace.id, {
       ...task,
-      status: queuedTaskIds.has(task.id) && (task.status === "open" || task.status === "ready" || task.status === "draft") ? "queued" : task.status
+      status: queuedTaskIds.has(task.id) && (task.status === "open" || task.status === "ready" || task.status === "draft" || task.status === "failed" || task.sourceStatus === "failed") ? "queued" : task.status
     }),
     graphId: graph.id
   }));

package/dist/src/server-helpers/snapshot-service.js

@@ -711,7 +711,7 @@ async function buildRigSnapshotPayload(projectRoot, readers) {
   const taskSummaries = (await readers.readWorkspaceTasks(projectRoot)).map((task) => ({
     ...toTaskSummary(workspace.id, {
       ...task,
-      status: queuedTaskIds.has(task.id) && (task.status === "open" || task.status === "ready" || task.status === "draft") ? "queued" : task.status
+      status: queuedTaskIds.has(task.id) && (task.status === "open" || task.status === "ready" || task.status === "draft" || task.status === "failed" || task.sourceStatus === "failed") ? "queued" : task.status
     }),
     graphId: graph.id
   }));

package/dist/src/server-helpers/ws-router.js

@@ -403,7 +403,7 @@ var TERMINAL_RUN_STATUSES2 = new Set([
   "needs-attention",
   "stopped"
 ]);
-var ORPHANABLE_LOCAL_RUN_STATUSES = new Set(["preparing", "running"]);
+var RESUMABLE_LOCAL_RUN_STATUSES = new Set(["created", "preparing", "running", "validating", "reviewing"]);
 
 // packages/server/src/server-helpers/http-router.ts
 import {
@@ -437,10 +437,10 @@ import {
   buildTaskRunLifecycleComment as buildTaskRunLifecycleComment2,
   updateConfiguredTaskSourceTask as updateConfiguredTaskSourceTask2
 } from "@rig/runtime/control-plane/tasks/source-lifecycle";
-var RIG_CONFIG_PACKAGE_VERSION = "0.0.6-alpha.1";
+var RIG_CONFIG_PACKAGE_DIST_TAG = "latest";
 var RIG_CONFIG_DEV_DEPENDENCIES = {
-  "@rig/core": `npm:@h-rig/core@${RIG_CONFIG_PACKAGE_VERSION}`,
-  "@rig/standard-plugin": `npm:@h-rig/standard-plugin@${RIG_CONFIG_PACKAGE_VERSION}`
+  "@rig/core": `npm:@h-rig/core@${RIG_CONFIG_PACKAGE_DIST_TAG}`,
+  "@rig/standard-plugin": `npm:@h-rig/standard-plugin@${RIG_CONFIG_PACKAGE_DIST_TAG}`
 };
 
 // packages/server/src/server-helpers/inspector-jobs.ts