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

package/dist/src/index.js

@@ -4383,11 +4383,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 = {
@@ -4459,6 +4471,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,
@@ -4475,9 +4488,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
@@ -4559,6 +4572,10 @@ async function startLocalRun(state, runId, options) {
             RIG_GITHUB_TOKEN: bridgeGitHubToken,
             GITHUB_TOKEN: bridgeGitHubToken,
             GH_TOKEN: bridgeGitHubToken
+          } : {},
+          ...resumeMode ? {
+            RIG_RUN_RESUME: "1",
+            RIG_RUNTIME_ARTIFACT_CLEANUP: "preserve"
           } : {}
         },
         stdio: ["ignore", "pipe", "pipe"]
@@ -4731,7 +4748,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);
@@ -4815,34 +4832,12 @@ function removeTaskIdsFromQueueState(projectRoot, taskIds) {
   writeQueueState(projectRoot, next);
   return next;
 }
-var ORPHANABLE_LOCAL_RUN_STATUSES = new Set(["preparing", "running"]);
-function reconcileOrphanedLocalRuns(state, runs, nowIso2) {
-  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 ?? nowIso2,
-      updatedAt: nowIso2,
-      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: nowIso2
-    });
-    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) {
@@ -4857,7 +4852,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);
         }
@@ -7254,11 +7262,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) {

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

@@ -1167,7 +1167,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/ws-router.ts
 import {
@@ -3545,11 +3545,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) {

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, {
@@ -1479,6 +1510,10 @@ async function startLocalRun(state, runId, options) {
             RIG_GITHUB_TOKEN: bridgeGitHubToken,
             GITHUB_TOKEN: bridgeGitHubToken,
             GH_TOKEN: bridgeGitHubToken
+          } : {},
+          ...resumeMode ? {
+            RIG_RUN_RESUME: "1",
+            RIG_RUNTIME_ARTIFACT_CLEANUP: "preserve"
           } : {}
         },
         stdio: ["ignore", "pipe", "pipe"]
@@ -1519,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}`);
@@ -1621,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 {}
@@ -1651,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",
@@ -1667,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
   });
@@ -1697,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 () => {
@@ -1735,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) {
@@ -1777,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

@@ -3876,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 = {
@@ -3952,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,
@@ -3968,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
@@ -4052,6 +4065,10 @@ async function startLocalRun(state, runId, options) {
             RIG_GITHUB_TOKEN: bridgeGitHubToken,
             GITHUB_TOKEN: bridgeGitHubToken,
             GH_TOKEN: bridgeGitHubToken
+          } : {},
+          ...resumeMode ? {
+            RIG_RUN_RESUME: "1",
+            RIG_RUNTIME_ARTIFACT_CLEANUP: "preserve"
           } : {}
         },
         stdio: ["ignore", "pipe", "pipe"]
@@ -4224,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);
@@ -4308,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) {
@@ -4350,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);
         }
@@ -6747,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) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@h-rig/server",
-  "version": "0.0.6-alpha.3",
+  "version": "0.0.6-alpha.4",
   "type": "module",
   "description": "Rig package",
   "license": "UNLICENSED",
@@ -25,9 +25,9 @@
     "rig-server": "./dist/src/server.js"
   },
   "dependencies": {
-    "@rig/contracts": "npm:@h-rig/contracts@0.0.6-alpha.3",
-    "@rig/core": "npm:@h-rig/core@0.0.6-alpha.3",
-    "@rig/runtime": "npm:@h-rig/runtime@0.0.6-alpha.3",
+    "@rig/contracts": "npm:@h-rig/contracts@0.0.6-alpha.4",
+    "@rig/core": "npm:@h-rig/core@0.0.6-alpha.4",
+    "@rig/runtime": "npm:@h-rig/runtime@0.0.6-alpha.4",
     "effect": "4.0.0-beta.78"
   }
 }