@h-rig/server 0.0.6-alpha.2 → 0.0.6-alpha.4

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) {
@@ -460,8 +478,8 @@ import {
 
 // packages/server/src/server-helpers/github-auth-store.ts
 import { randomBytes } from "crypto";
-import { chmodSync, existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync, writeFileSync as writeFileSync3 } from "fs";
-import { resolve as resolve6 } from "path";
+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;
 }
@@ -492,10 +510,10 @@ function parseApiSessions(value) {
   });
 }
 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),
@@ -527,15 +545,15 @@ 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);
@@ -969,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 {
@@ -989,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);
@@ -1026,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;
@@ -1074,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
@@ -1088,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;
     }
@@ -1303,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 = {
@@ -1341,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,
@@ -1379,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,
@@ -1395,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
@@ -1405,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, {
@@ -1475,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"]
       });
@@ -1515,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}`);
@@ -1617,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 {}
@@ -1647,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",
@@ -1663,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
   });
@@ -1693,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 () => {
@@ -1731,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) {
@@ -1773,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/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 {

package/dist/src/server.js

@@ -2463,7 +2463,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);
@@ -3873,11 +3876,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 = resolveAuthorityRunDir3(projectRoot, input.runId);
   const runRecord = {
@@ -3949,6 +3964,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,
@@ -3965,9 +3981,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
@@ -4045,7 +4061,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"]
       });
@@ -4217,7 +4241,7 @@ 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 = readAuthorityRun4(projectRoot, input.runId);
@@ -4301,34 +4325,12 @@ function removeTaskIdsFromQueueState(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) {
@@ -4343,7 +4345,20 @@ async function reconcileScheduler(state, reason) {
         const queue = readQueueState(state.projectRoot);
         const tasks = await state.snapshotService.getWorkspaceTasks();
         let runs = listAuthorityRuns4(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 = listAuthorityRuns4(state.projectRoot);
         }
@@ -5621,6 +5636,27 @@ function filterWorkspaceTasks(projectRoot, tasks, searchParams) {
   }
   return filtered;
 }
+function issueAnalysisTargetFor(source) {
+  if (!source)
+    return null;
+  const candidate = source;
+  if (typeof candidate.updateTask !== "function")
+    return null;
+  return {
+    ...typeof candidate.get === "function" ? { get: candidate.get.bind(candidate) } : {},
+    updateTask: candidate.updateTask.bind(candidate),
+    ...typeof candidate.addLabels === "function" ? { addLabels: candidate.addLabels.bind(candidate) } : {},
+    ...typeof candidate.removeLabels === "function" ? { removeLabels: candidate.removeLabels.bind(candidate) } : {},
+    ...typeof candidate.createIssue === "function" ? { createIssue: candidate.createIssue.bind(candidate) } : {}
+  };
+}
+function uniqueStringList(value) {
+  const raw = Array.isArray(value) ? value : typeof value === "string" ? [value] : [];
+  return [...new Set(raw.map((entry) => String(entry).trim()).filter(Boolean))];
+}
+function taskRecordId(task) {
+  return String(task.id ?? "");
+}
 function redactRemoteEndpoint(endpoint) {
   const { token, ...rest } = endpoint;
   return {
@@ -5963,6 +5999,67 @@ data: ${JSON.stringify({ connectedAt: new Date().toISOString() })}
             note: "GitHub issue lifecycle labels are created on demand by the configured task source when supported."
           });
         }
+        if (url.pathname === "/api/workspace/issue-analysis/run" && req.method === "POST") {
+          const body = await deps.readJsonBody(req);
+          const ids = uniqueStringList(body.ids ?? body.id);
+          const analyzeAll = deps.isTruthyQuery(String(body.all ?? ""));
+          if (ids.length === 0 && !analyzeAll) {
+            return deps.badRequest("ids is required unless all=true");
+          }
+          const ctx = await getCachedPluginHostContext(state.projectRoot);
+          const [source] = ctx?.taskSourceRegistry.list() ?? [];
+          const target = issueAnalysisTargetFor(source);
+          if (!source || !target) {
+            return deps.badRequest("Configured task source does not support issue-analysis writeback");
+          }
+          const allTasks = [...await source.list()];
+          const issues = analyzeAll ? allTasks.slice(0, Math.max(1, Math.min(25, Number(body.limit ?? 25) || 25))) : (await Promise.all(ids.map(async (id) => {
+            const cached = allTasks.find((task) => taskRecordId(task) === id);
+            if (cached)
+              return cached;
+            return typeof source.get === "function" ? await source.get(id) : undefined;
+          }))).filter((task) => Boolean(task));
+          if (issues.length === 0) {
+            return deps.jsonResponse({ ok: false, error: "No matching issues found for issue analysis", ids }, 404);
+          }
+          const config = ctx?.config && typeof ctx.config === "object" ? ctx.config : {};
+          const issueAnalysis = config.issueAnalysis && typeof config.issueAnalysis === "object" ? config.issueAnalysis : {};
+          const runtime = config.runtime && typeof config.runtime === "object" ? config.runtime : {};
+          const model = normalizeString(issueAnalysis.model) ?? normalizeString(runtime.model);
+          const service = createIssueAnalysisService({
+            analyzer: createPiIssueAnalyzer({
+              ...model ? { model } : {},
+              env: { RIG_PROJECT_ROOT: state.projectRoot }
+            }),
+            writeBack: createIssueAnalysisWriteBack({ target })
+          });
+          const reason = normalizeString(body.reason) ?? "http-issue-analysis";
+          let results;
+          try {
+            results = await service.analyze(issues, { reason, neighbors: ids.length > 0 ? issues : allTasks });
+          } catch (error) {
+            return deps.jsonResponse({
+              ok: false,
+              error: `Issue analysis failed: ${error instanceof Error ? error.message : String(error)}`,
+              reason,
+              ids: issues.map((issue) => issue.id)
+            }, 502);
+          }
+          deps.snapshotService.invalidate("issue-analysis-http-run");
+          await state.taskProjectionReconciler?.tick("issue-analysis-http-run").catch(() => {
+            return;
+          });
+          deps.broadcastSnapshotInvalidation(state, "issue-analysis-http-run");
+          return deps.jsonResponse({
+            ok: true,
+            reason,
+            analyzed: results.map((entry) => ({
+              id: entry.issue.id,
+              title: entry.issue.title ?? null,
+              result: entry.result
+            }))
+          });
+        }
         if (url.pathname === "/api/server/status") {
           const config = buildProjectConfigStatus(state.projectRoot);
           const taskSource = await buildTaskSourceStatus(state, config);
@@ -6658,11 +6755,12 @@ data: ${JSON.stringify({ connectedAt: new Date().toISOString() })}
           const runId = normalizeString(body.runId);
           const createdAt = normalizeString(body.createdAt) ?? new Date().toISOString();
           const promptOverride = normalizeString(body.promptOverride);
+          const restart = body.restart === true;
           if (!runId) {
             return deps.badRequest("runId is required");
           }
           try {
-            await deps.resumeRunRecord(state, { runId, createdAt, promptOverride });
+            await deps.resumeRunRecord(state, { runId, createdAt, promptOverride, restart });
             deps.broadcastSnapshotInvalidation(state);
             return deps.jsonResponse({ ok: true, runId, createdAt });
           } catch (error) {
@@ -12572,6 +12670,7 @@ async function createRigServer(options, projectRoot = resolveProjectRoot()) {
   const server = Bun.serve({
     hostname: options.host,
     port: options.port,
+    idleTimeout: Math.max(10, Math.min(255, Number.parseInt(process.env.RIG_SERVER_IDLE_TIMEOUT_SECONDS || "255", 10) || 255)),
     fetch: (req, server2) => createRigServerFetch2(state)(req, server2),
     websocket: {
       open(ws) {