@h-rig/server 0.0.6-alpha.13 → 0.0.6-alpha.14

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

@@ -16,6 +16,11 @@ import {
   buildTaskRunLifecycleComment as buildTaskRunLifecycleComment2,
   updateConfiguredTaskSourceTask as updateConfiguredTaskSourceTask2
 } from "@rig/runtime/control-plane/tasks/source-lifecycle";
+import {
+  closeIssueAfterMergedPr,
+  commitRunChanges,
+  runPrAutomation
+} from "@rig/runtime/control-plane/native/pr-automation";
 
 // packages/server/src/scheduler.ts
 import { normalizeTaskLifecycleStatus } from "@rig/runtime/control-plane/state-sync/types";
@@ -180,6 +185,9 @@ import {
   readJsonlFile,
   resolveAuthorityRunDir
 } from "@rig/runtime/control-plane/authority-files";
+function runTimelinePath(projectRoot, runId) {
+  return resolve2(resolveAuthorityRunDir(projectRoot, runId), "timeline.jsonl");
+}
 function runLogsPath(projectRoot, runId) {
   return resolve2(resolveAuthorityRunDir(projectRoot, runId), "logs.jsonl");
 }
@@ -327,6 +335,13 @@ import {
   resolveAuthorityRunDir as resolveAuthorityRunDir2,
   writeJsonFile as writeJsonFile2
 } from "@rig/runtime/control-plane/authority-files";
+function appendRunTimelineEntry(projectRoot, runId, value) {
+  if (!readAuthorityRun3(projectRoot, runId)) {
+    return;
+  }
+  appendJsonlRecord(runTimelinePath(projectRoot, runId), value);
+  patchRunRecord(projectRoot, runId, {});
+}
 function appendRunLogEntry(projectRoot, runId, value) {
   if (!readAuthorityRun3(projectRoot, runId)) {
     return;
@@ -353,8 +368,7 @@ function buildRunStartPatch(startedAt) {
     status: "preparing",
     startedAt,
     completedAt: null,
-    errorText: null,
-    serverPid: process.pid
+    errorText: null
   };
 }
 
@@ -812,6 +826,7 @@ var DEFAULT_PROJECT_STATUSES = {
   running: "In Progress",
   prOpen: "In Review",
   ciFixing: "In Review",
+  merging: "Merging",
   done: "Done",
   needsAttention: "Needs Attention"
 };
@@ -825,6 +840,8 @@ function lifecycleStatusForTaskStatus(status) {
     return "prOpen";
   if (normalized === "ci_fixing" || normalized === "fixing")
     return "ciFixing";
+  if (normalized === "merging" || normalized === "merge")
+    return "merging";
   if (normalized === "failed" || normalized === "needs_attention" || normalized === "blocked")
     return "needsAttention";
   if (normalized === "in_progress" || normalized === "running" || normalized === "ready" || normalized === "open")
@@ -1228,9 +1245,14 @@ function parseIssueRef(sourceTask, fallbackTaskId) {
     return null;
   return null;
 }
+function githubProjectsEnabled(config) {
+  const github = config?.github && typeof config.github === "object" && !Array.isArray(config.github) ? config.github : null;
+  const projects = github?.projects && typeof github.projects === "object" && !Array.isArray(github.projects) ? github.projects : null;
+  return projects?.enabled === true;
+}
 async function syncProjectStatusForRunLifecycle(projectRoot, run, status, config) {
   if (!run.taskId)
-    return;
+    return false;
   const issueNodeId = extractGitHubIssueNodeId(runSourceTaskIdentity(run));
   try {
     const result = await syncGitHubProjectStatusForTaskUpdate({
@@ -1241,28 +1263,86 @@ async function syncProjectStatusForRunLifecycle(projectRoot, run, status, config
       config
     });
     if (!result.synced && result.reason !== "project-sync-disabled") {
+      const detail = `Project status sync for ${run.taskId} could not run: ${result.reason}.`;
       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}.`,
+        detail,
         tone: "warn",
         status: "running",
         createdAt: new Date().toISOString(),
         payload: { reason: result.reason, issueNodeId }
       });
+      if (githubProjectsEnabled(config)) {
+        throw new Error(detail);
+      }
+      return false;
     }
+    return result.synced === true;
   } catch (error) {
+    const detail = error instanceof Error ? error.message : String(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),
+      detail,
       tone: "error",
       status: "running",
       createdAt: new Date().toISOString(),
       payload: { issueNodeId }
     });
+    if (githubProjectsEnabled(config)) {
+      throw new Error(detail);
+    }
+    return false;
   }
 }
+function createCommandRunner(binary, extraEnv = {}) {
+  return async (args, options) => {
+    const child = spawn(binary, [...args], {
+      cwd: options?.cwd,
+      env: { ...process.env, ...extraEnv },
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    const stdoutChunks = [];
+    const stderrChunks = [];
+    child.stdout?.on("data", (chunk) => stdoutChunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk))));
+    child.stderr?.on("data", (chunk) => stderrChunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk))));
+    const exitCode = await new Promise((resolve11) => {
+      child.once("error", () => resolve11(1));
+      child.once("close", (code) => resolve11(code ?? 1));
+    });
+    return {
+      exitCode,
+      stdout: Buffer.concat(stdoutChunks).toString("utf8"),
+      stderr: Buffer.concat(stderrChunks).toString("utf8")
+    };
+  };
+}
+function closeoutRecord(run) {
+  const value = run.serverCloseout;
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function closeoutPhasePatch(phase, status, extra = {}) {
+  const updatedAt = new Date().toISOString();
+  return {
+    serverCloseout: {
+      phase,
+      status,
+      updatedAt,
+      ...extra
+    }
+  };
+}
+function appendCloseoutStage(state, runId, phase, detail, status = "reviewing", tone = "info") {
+  appendRunLogEntryAndBroadcast(state, runId, {
+    id: `log:${runId}:server-closeout:${phase}:${Date.now()}`,
+    title: `Server closeout: ${phase}`,
+    detail,
+    tone,
+    status,
+    createdAt: new Date().toISOString()
+  }, `server-closeout-${phase}`);
+}
 async function autoAssignRunIssue(projectRoot, run) {
   if (!run.taskId)
     return;
@@ -1292,7 +1372,7 @@ async function updateRunTaskSourceLifecycle(projectRoot, run, status, summary, o
     return;
   }
   const config = await loadRigLifecycleConfig(projectRoot);
-  await syncProjectStatusForRunLifecycle(projectRoot, run, status, config);
+  const projectSynced = await syncProjectStatusForRunLifecycle(projectRoot, run, status, config);
   if (status === "in_progress") {
     await autoAssignRunIssue(projectRoot, run);
   }
@@ -1308,24 +1388,53 @@ async function updateRunTaskSourceLifecycle(projectRoot, run, status, summary, o
     });
     return;
   }
-  const result = await updateConfiguredTaskSourceTask2(projectRoot, {
-    taskId: run.taskId,
-    sourceTask: runSourceTaskIdentity(run),
-    update: {
-      status,
-      comment: buildTaskRunLifecycleComment2({
-        runId: run.runId,
+  const sourceTask = runSourceTaskIdentity(run);
+  const previousStatus = normalizeString(sourceTask?.status) ?? normalizeString(sourceTask?.sourceStatus);
+  const rollbackProjectSync = async () => {
+    if (!projectSynced || !previousStatus || !run.taskId || !githubProjectsEnabled(config))
+      return;
+    await syncGitHubProjectStatusForTaskUpdate({
+      taskId: run.taskId,
+      status: previousStatus,
+      issueNodeId: extractGitHubIssueNodeId(sourceTask),
+      token: createGitHubAuthStore(projectRoot).readToken(),
+      config
+    }).catch((rollbackError) => {
+      appendRunLogEntry(projectRoot, run.runId, {
+        id: `log:${run.runId}:github-project-sync-rollback:${status}`,
+        title: "GitHub Project sync rollback failed",
+        detail: rollbackError instanceof Error ? rollbackError.message : String(rollbackError),
+        tone: "error",
+        status: "running",
+        createdAt: new Date().toISOString()
+      });
+    });
+  };
+  let result;
+  try {
+    result = await updateConfiguredTaskSourceTask2(projectRoot, {
+      taskId: run.taskId,
+      sourceTask,
+      update: {
         status,
-        summary,
-        runtimeWorkspace: normalizeString(run.worktreePath),
-        logsDir: normalizeString(run.logRoot),
-        sessionDir: normalizeString(run.sessionPath),
-        errorText: options.errorText ?? normalizeString(run.errorText)
-      })
-    }
-  });
+        comment: buildTaskRunLifecycleComment2({
+          runId: run.runId,
+          status,
+          summary,
+          runtimeWorkspace: normalizeString(run.worktreePath),
+          logsDir: normalizeString(run.logRoot),
+          sessionDir: normalizeString(run.sessionPath),
+          errorText: options.errorText ?? normalizeString(run.errorText)
+        })
+      }
+    });
+  } catch (error) {
+    await rollbackProjectSync();
+    throw error;
+  }
   if (!result.updated) {
     if (result.source === "plugin" || result.sourceKind) {
+      await rollbackProjectSync();
       throw new Error(`Configured task source${result.sourceKind ? ` (${result.sourceKind})` : ""} did not accept lifecycle update for ${result.taskId}.`);
     }
     appendRunLogEntry(projectRoot, run.runId, {
@@ -1338,6 +1447,219 @@ async function updateRunTaskSourceLifecycle(projectRoot, run, status, summary, o
     });
   }
 }
+async function runServerOwnedPrCloseout(state, runId) {
+  const run = readAuthorityRun8(state.projectRoot, runId);
+  if (!run)
+    throw new Error(`Run not found: ${runId}`);
+  const closeout = closeoutRecord(run);
+  if (!closeout)
+    return;
+  const taskId = normalizeString(closeout.taskId) ?? normalizeString(run.taskId);
+  if (!taskId)
+    throw new Error("Server-owned closeout requires a task id.");
+  const workspace = normalizeString(closeout.runtimeWorkspace) ?? normalizeString(run.worktreePath) ?? state.projectRoot;
+  const branch = normalizeString(closeout.branch) ?? `rig/${taskId}-${runId}`;
+  const config = await loadRigLifecycleConfig(state.projectRoot);
+  const runPrMode = normalizeString(run.prMode);
+  const prMode = runPrMode === "auto" || runPrMode === "ask" || runPrMode === "off" ? runPrMode : config?.pr?.mode ?? "off";
+  const effectiveConfig = {
+    ...config ?? {},
+    pr: {
+      ...config?.pr ?? {},
+      mode: prMode,
+      autoFixChecks: false,
+      autoFixReview: false
+    }
+  };
+  const readCurrentRun = () => readAuthorityRun8(state.projectRoot, runId) ?? run;
+  const sourceTask = runSourceTaskIdentity(run);
+  const closeoutPhase = normalizeString(closeout.phase)?.toLowerCase() ?? "";
+  const closeoutStatus = normalizeString(closeout.status)?.toLowerCase() ?? "";
+  const closeoutPrUrl = normalizeString(closeout.prUrl);
+  if (closeoutPhase === "completed" || closeoutStatus === "completed") {
+    return;
+  }
+  if (closeoutPhase === "close-source" && closeoutPrUrl) {
+    patchRunRecord(state.projectRoot, runId, {
+      status: "reviewing",
+      ...closeoutPhasePatch("close-source", "running", { ...closeout, prUrl: closeoutPrUrl, taskId, runtimeWorkspace: workspace, branch })
+    });
+    await closeIssueAfterMergedPr({
+      projectRoot: state.projectRoot,
+      taskId,
+      runId,
+      prUrl: closeoutPrUrl,
+      sourceTask,
+      updateTaskSource: async (projectRoot, input) => {
+        await updateRunTaskSourceLifecycle(projectRoot, readCurrentRun(), "closed", "Rig merged the pull request and closed this task source.");
+        return { updated: true, taskId: input.taskId, status: input.update.status, source: "server", sourceKind: "server" };
+      }
+    });
+    const completedAt = new Date().toISOString();
+    patchRunRecord(state.projectRoot, runId, {
+      status: "completed",
+      completedAt,
+      errorText: null,
+      ...closeoutPhasePatch("completed", "completed", { ...closeout, prUrl: closeoutPrUrl, iterations: closeout.iterations, completedAt })
+    });
+    appendCloseoutStage(state, runId, "completed", `PR merged and issue closed: ${closeoutPrUrl}`, "completed", "info");
+    emitRigEvent(state, {
+      type: "rig.run.completed",
+      aggregateId: runId,
+      payload: { runId, taskId, prUrl: closeoutPrUrl, closeout: "merged" },
+      createdAt: completedAt
+    });
+    return;
+  }
+  if (prMode === "off" || prMode === "ask") {
+    const completedAt = new Date().toISOString();
+    patchRunRecord(state.projectRoot, runId, {
+      status: "completed",
+      completedAt,
+      errorText: null,
+      ...closeoutPhasePatch("completed", "completed", { taskId, runtimeWorkspace: workspace, branch, reason: prMode === "ask" ? "pr-mode-ask" : "pr-mode-off" })
+    });
+    appendCloseoutStage(state, runId, "completed", prMode === "ask" ? "Validation completed; PR creation awaits operator approval." : "Validation completed; PR automation disabled.", "completed", "info");
+    emitRigEvent(state, {
+      type: "rig.run.completed",
+      aggregateId: runId,
+      payload: { runId, taskId, closeout: "skipped", reason: prMode === "ask" ? "pr-mode-ask" : "pr-mode-off" },
+      createdAt: completedAt
+    });
+    return;
+  }
+  const githubToken = createGitHubAuthStore(state.projectRoot).readToken();
+  const githubEnv = githubToken ? { RIG_GITHUB_TOKEN: githubToken, GITHUB_TOKEN: githubToken, GH_TOKEN: githubToken } : {};
+  const gitCommand = createCommandRunner("git", githubEnv);
+  const ghCommand = createCommandRunner("gh", githubEnv);
+  const setCloseout = (phase, status, extra = {}) => {
+    const previous = closeoutRecord(readCurrentRun()) ?? closeout;
+    patchRunRecord(state.projectRoot, runId, {
+      status: status === "failed" ? "failed" : status === "needs_attention" ? "needs_attention" : "reviewing",
+      ...closeoutPhasePatch(phase, status, { ...previous, ...extra })
+    });
+  };
+  setCloseout("commit", "running", { runtimeWorkspace: workspace, branch, taskId });
+  appendCloseoutStage(state, runId, "commit", `Committing changes in ${workspace}.`, "reviewing", "tool");
+  const commit = await commitRunChanges({ cwd: workspace, message: `rig: complete task ${taskId}`, command: gitCommand });
+  appendCloseoutStage(state, runId, "commit", commit.committed ? "Committed run workspace changes." : "No workspace changes to commit.", "reviewing", "tool");
+  setCloseout("push", "running", { runtimeWorkspace: workspace, branch, taskId });
+  const push = await gitCommand(["push", "--set-upstream", "origin", branch], { cwd: workspace });
+  if (push.exitCode !== 0) {
+    throw new Error(`git push --set-upstream origin ${branch} failed (${push.exitCode}): ${push.stderr ?? push.stdout ?? ""}`.trim());
+  }
+  const sourceTaskForPr = {
+    title: normalizeString(sourceTask?.title) ?? normalizeString(run.title)
+  };
+  const artifactRoot = resolve10(state.projectRoot, "artifacts", taskId);
+  setCloseout("pr-review-merge", "running", { runtimeWorkspace: workspace, branch, taskId, artifactRoot });
+  const pr = await runPrAutomation({
+    projectRoot: workspace,
+    taskId,
+    runId,
+    branch,
+    config: effectiveConfig,
+    sourceTask: sourceTaskForPr,
+    artifactRoot,
+    command: ghCommand,
+    gitCommand,
+    steerPi: async (message) => {
+      appendCloseoutStage(state, runId, "feedback", message, "reviewing", "info");
+      appendRunTimelineEntry(state.projectRoot, runId, {
+        id: `message:${runId}:server-closeout-feedback:${Date.now()}`,
+        type: "user_message",
+        text: message,
+        createdAt: new Date().toISOString(),
+        state: "completed"
+      });
+    },
+    lifecycle: {
+      onPrOpened: async ({ prUrl }) => {
+        setCloseout("pr-opened", "running", { prUrl, runtimeWorkspace: workspace, branch, taskId, artifactRoot });
+        appendCloseoutStage(state, runId, "open-pr", prUrl, "reviewing", "tool");
+        await updateRunTaskSourceLifecycle(state.projectRoot, readCurrentRun(), "under_review", "Rig opened a pull request for this task.");
+      },
+      onReviewCiStarted: ({ prUrl, iteration }) => appendCloseoutStage(state, runId, "review-ci", `${prUrl} (iteration ${iteration})`, "reviewing", "info"),
+      onFeedback: async ({ feedback }) => {
+        appendCloseoutStage(state, runId, "feedback", feedback.join(`
+`), "reviewing", "error");
+        await updateRunTaskSourceLifecycle(state.projectRoot, readCurrentRun(), "ci_fixing", "Rig is fixing CI/review feedback for this task.");
+      },
+      onMergeStarted: async ({ prUrl }) => {
+        setCloseout("merge", "running", { prUrl, runtimeWorkspace: workspace, branch, taskId, artifactRoot });
+        appendCloseoutStage(state, runId, "merge", prUrl, "reviewing", "tool");
+        await updateRunTaskSourceLifecycle(state.projectRoot, readCurrentRun(), "merging", "Rig is merging the pull request for this task.");
+      },
+      onMerged: ({ prUrl }) => {
+        setCloseout("close-source", "running", { prUrl, runtimeWorkspace: workspace, branch, taskId, artifactRoot, merged: true });
+        appendCloseoutStage(state, runId, "merge", prUrl, "reviewing", "tool");
+      }
+    }
+  });
+  if (pr.status === "merged" && pr.prUrl) {
+    setCloseout("close-source", "running", { prUrl: pr.prUrl, iterations: pr.iterations });
+    await closeIssueAfterMergedPr({
+      projectRoot: state.projectRoot,
+      taskId,
+      runId,
+      prUrl: pr.prUrl,
+      sourceTask,
+      updateTaskSource: async (projectRoot, input) => {
+        await updateRunTaskSourceLifecycle(projectRoot, readCurrentRun(), "closed", "Rig merged the pull request and closed this task source.");
+        return { updated: true, taskId: input.taskId, status: input.update.status, source: "server", sourceKind: "server" };
+      }
+    });
+    const completedAt = new Date().toISOString();
+    patchRunRecord(state.projectRoot, runId, {
+      status: "completed",
+      completedAt,
+      errorText: null,
+      ...closeoutPhasePatch("completed", "completed", { prUrl: pr.prUrl, iterations: pr.iterations, completedAt })
+    });
+    appendCloseoutStage(state, runId, "completed", `PR merged and issue closed: ${pr.prUrl}`, "completed", "info");
+    emitRigEvent(state, {
+      type: "rig.run.completed",
+      aggregateId: runId,
+      payload: { runId, taskId, prUrl: pr.prUrl, closeout: "merged" },
+      createdAt: completedAt
+    });
+    return;
+  }
+  if (pr.status === "opened" && pr.prUrl) {
+    const completedAt = new Date().toISOString();
+    patchRunRecord(state.projectRoot, runId, {
+      status: "completed",
+      completedAt,
+      errorText: null,
+      ...closeoutPhasePatch("completed", "completed", { prUrl: pr.prUrl, iterations: pr.iterations })
+    });
+    appendCloseoutStage(state, runId, "completed", `PR ready without merge: ${pr.prUrl}`, "completed", "info");
+    emitRigEvent(state, {
+      type: "rig.run.completed",
+      aggregateId: runId,
+      payload: { runId, taskId, prUrl: pr.prUrl, closeout: "pr-ready" },
+      createdAt: completedAt
+    });
+    return;
+  }
+  const detail = pr.actionableFeedback.join(`
+`) || "PR automation did not merge the PR.";
+  await updateRunTaskSourceLifecycle(state.projectRoot, readCurrentRun(), "needs_attention", "Rig needs operator attention before this task can proceed.", { errorText: detail }).catch((error) => {
+    appendCloseoutStage(state, runId, "needs-attention-update", error instanceof Error ? error.message : String(error), "needs_attention", "error");
+  });
+  patchRunRecord(state.projectRoot, runId, {
+    status: "needs_attention",
+    completedAt: new Date().toISOString(),
+    errorText: detail,
+    ...closeoutPhasePatch("needs_attention", "needs_attention", { feedback: pr.actionableFeedback, prUrl: pr.prUrl ?? null, iterations: pr.iterations })
+  });
+  appendCloseoutStage(state, runId, "needs-attention", detail, "needs_attention", "error");
+  emitRigEvent(state, {
+    type: "rig.run.needs-attention",
+    aggregateId: runId,
+    payload: { runId, taskId, error: detail, prUrl: pr.prUrl ?? null }
+  });
+}
 var TERMINAL_RUN_STATUSES2 = new Set([
   "completed",
   "complete",
@@ -1546,6 +1868,7 @@ async function startLocalRun(state, runId, options) {
           RIG_HOST_PROJECT_ROOT: cliProjectRoot,
           RIG_RUNTIME_BASE_REF: process.env.RIG_RUNTIME_BASE_REF ?? "HEAD",
           RIG_SERVER_INTERNAL_EXEC: "1",
+          RIG_SERVER_OWNS_CLOSEOUT: "1",
           ...serverUrl ? { RIG_SERVER_URL: serverUrl } : {},
           ...bridgeAuthToken ? { RIG_AUTH_TOKEN: bridgeAuthToken } : {},
           ...bridgeGitHubToken ? {
@@ -1642,6 +1965,38 @@ ${sourceFailure}` });
             agent: current.runtimeAdapter,
             summary: failureSummary
           });
+        } else if (closeoutRecord(current)?.status === "pending") {
+          try {
+            await runServerOwnedPrCloseout(state, runId);
+          } catch (closeoutError) {
+            const closeoutFailure = closeoutError instanceof Error ? closeoutError.message : String(closeoutError);
+            patchRunRecord(state.projectRoot, runId, {
+              status: "failed",
+              completedAt: new Date().toISOString(),
+              errorText: closeoutFailure,
+              ...closeoutPhasePatch("failed", "failed", { error: closeoutFailure })
+            });
+            appendRunLogEntryAndBroadcast(state, runId, {
+              id: `log:${runId}:server-closeout-failed`,
+              title: "Server-owned closeout failed",
+              detail: closeoutFailure,
+              tone: "error",
+              status: "failed",
+              createdAt: new Date().toISOString()
+            }, "server-closeout-failed");
+            if (current.taskId) {
+              await updateRunTaskSourceLifecycle(state.projectRoot, { ...current, status: "failed", errorText: closeoutFailure }, "failed", "Rig server-owned closeout failed.", { errorText: closeoutFailure }).catch((error) => {
+                appendRunLogEntry(state.projectRoot, runId, {
+                  id: `log:${runId}:task-source-closeout-failed-update`,
+                  title: "Task source closeout failure update failed",
+                  detail: error instanceof Error ? error.message : String(error),
+                  tone: "error",
+                  status: "failed",
+                  createdAt: new Date().toISOString()
+                });
+              });
+            }
+          }
         }
         broadcastSnapshotInvalidation(state);
       } catch (error) {
@@ -1728,6 +2083,12 @@ async function resumeRunRecord(state, input) {
   if (run.status === "completed") {
     throw new Error("Completed runs cannot be resumed.");
   }
+  const closeout = closeoutRecord(run);
+  const closeoutStatus = normalizeString(closeout?.status)?.toLowerCase() ?? "";
+  if (RESUMABLE_SERVER_CLOSEOUT_STATUSES.has(closeoutStatus)) {
+    await runServerOwnedPrCloseout(state, input.runId);
+    return;
+  }
   await startLocalRun(state, input.runId, { promptOverride: input.promptOverride ?? null, resume: input.restart !== true });
 }
 function appendRunMessage(projectRoot, input) {
@@ -1812,11 +2173,45 @@ function removeTaskIdsFromQueueState2(projectRoot, taskIds) {
   writeQueueState(projectRoot, next);
   return next;
 }
-var RESUMABLE_LOCAL_RUN_STATUSES = new Set(["created", "preparing", "running", "validating", "reviewing"]);
-function collectResumableLocalRuns(state, runs) {
+var RESUMABLE_SERVER_CLOSEOUT_STATUSES = new Set(["pending", "running"]);
+var ACTIVE_LOCAL_RUN_STATUSES = new Set(["created", "preparing", "running", "validating", "reviewing"]);
+function processExists(pid) {
+  if (!Number.isInteger(pid) || pid <= 0)
+    return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function recoverStaleLocalRun(projectRoot, run) {
+  const record = run;
+  if (run.mode !== "local")
+    return false;
+  const status = normalizeString(record.status)?.toLowerCase() ?? "";
+  if (!ACTIVE_LOCAL_RUN_STATUSES.has(status))
+    return false;
+  const serverPid = typeof record.serverPid === "number" ? record.serverPid : null;
+  const childPid = typeof record.pid === "number" ? record.pid : null;
+  if (serverPid === null && childPid === null)
+    return false;
+  const hasLiveRecordedProcess = [serverPid, childPid].some((pid) => typeof pid === "number" && processExists(pid));
+  if (hasLiveRecordedProcess && serverPid === process.pid)
+    return false;
+  const completedAt = new Date().toISOString();
+  patchRunRecord(projectRoot, run.runId, {
+    status: "failed",
+    completedAt,
+    errorText: `Recovered stale local run ${run.runId} after server startup; no active server-owned process was tracking it.`
+  });
+  return true;
+}
+function collectResumableServerCloseouts(state, runs) {
   return runs.filter((run) => {
-    const status = normalizeString(run.status)?.toLowerCase() ?? "";
-    return run.mode === "local" && RESUMABLE_LOCAL_RUN_STATUSES.has(status) && !state.runProcesses.has(run.runId);
+    const closeout = closeoutRecord(run);
+    const closeoutStatus = normalizeString(closeout?.status)?.toLowerCase() ?? "";
+    return run.mode === "local" && RESUMABLE_SERVER_CLOSEOUT_STATUSES.has(closeoutStatus) && !state.runProcesses.has(run.runId);
   });
 }
 async function reconcileScheduler(state, reason) {
@@ -1833,17 +2228,33 @@ async function reconcileScheduler(state, reason) {
         const tasks = await state.snapshotService.getWorkspaceTasks();
         let runs = listAuthorityRuns7(state.projectRoot);
         let changed = false;
-        const resumableRuns = collectResumableLocalRuns(state, runs);
-        for (const run of resumableRuns) {
+        for (const run of runs) {
+          if (!state.runProcesses.has(run.runId) && recoverStaleLocalRun(state.projectRoot, run)) {
+            changed = true;
+          }
+        }
+        if (changed) {
+          runs = listAuthorityRuns7(state.projectRoot);
+        }
+        const resumableCloseouts = collectResumableServerCloseouts(state, runs);
+        for (const run of resumableCloseouts) {
           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.`,
+            id: `log:${run.runId}:server-closeout-auto-resume:${Date.now()}`,
+            title: "Server-owned closeout auto-resume scheduled",
+            detail: `Rig server recovered closeout checkpoint ${run.runId} after ${reason}; resuming the server-owned lifecycle phase.`,
             tone: "info",
-            status: "preparing",
+            status: "reviewing",
             createdAt: new Date().toISOString()
           });
-          await startLocalRun(state, run.runId, { resume: true });
+          await runServerOwnedPrCloseout(state, run.runId).catch((error) => {
+            const detail = error instanceof Error ? error.message : String(error);
+            patchRunRecord(state.projectRoot, run.runId, {
+              status: "failed",
+              completedAt: new Date().toISOString(),
+              errorText: detail,
+              ...closeoutPhasePatch("failed", "failed", { error: detail })
+            });
+          });
           changed = true;
         }
         if (changed) {
@@ -1918,8 +2329,10 @@ async function reconcileScheduler(state, reason) {
   }
 }
 export {
+  updateRunTaskSourceLifecycle,
   stopRunRecord,
   startLocalRun,
+  runServerOwnedPrCloseout,
   resumeRunRecord,
   resolveLocalRunCliProjectRoot,
   removeTaskIdsFromQueueState2 as removeTaskIdsFromQueueState,

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

@@ -63,8 +63,7 @@ function buildRunStartPatch(startedAt) {
     status: "preparing",
     startedAt,
     completedAt: null,
-    errorText: null,
-    serverPid: process.pid
+    errorText: null
   };
 }
 export {

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

@@ -376,6 +376,11 @@ import {
   buildTaskRunLifecycleComment,
   updateConfiguredTaskSourceTask
 } from "@rig/runtime/control-plane/tasks/source-lifecycle";
+import {
+  closeIssueAfterMergedPr,
+  commitRunChanges,
+  runPrAutomation
+} from "@rig/runtime/control-plane/native/pr-automation";
 
 // packages/server/src/scheduler.ts
 import { normalizeTaskLifecycleStatus } from "@rig/runtime/control-plane/state-sync/types";
@@ -403,7 +408,8 @@ var TERMINAL_RUN_STATUSES2 = new Set([
   "needs-attention",
   "stopped"
 ]);
-var RESUMABLE_LOCAL_RUN_STATUSES = new Set(["created", "preparing", "running", "validating", "reviewing"]);
+var RESUMABLE_SERVER_CLOSEOUT_STATUSES = new Set(["pending", "running"]);
+var ACTIVE_LOCAL_RUN_STATUSES = new Set(["created", "preparing", "running", "validating", "reviewing"]);
 
 // packages/server/src/server-helpers/http-router.ts
 import {