@a9n-shoji/rvw 0.3.0 → 0.3.1

package/dist/cli.mjs

@@ -7,6 +7,7 @@ var __export = (target, all4) => {
 
 // src/cli/main.ts
 import { fork } from "node:child_process";
+import { randomUUID as randomUUID6 } from "node:crypto";
 import { existsSync as existsSync6 } from "node:fs";
 import path10 from "node:path";
 import { fileURLToPath as fileURLToPath5, pathToFileURL } from "node:url";
@@ -19093,6 +19094,11 @@ var RvwDatabase = class {
   listPullRequests() {
     return this.database.prepare("SELECT * FROM pull_requests ORDER BY updated_at DESC").all().map(mapPullRequest);
   }
+  listPullRequestsNeedingStatusRefresh() {
+    return this.database.prepare(
+      "SELECT * FROM pull_requests WHERE github_state = 'OPEN' OR github_state IS NULL ORDER BY updated_at DESC"
+    ).all().map(mapPullRequest);
+  }
   listPullRequestSummaries(offset, limit, hideClosedOrMerged = true) {
     const hideClosedOrMergedValue = hideClosedOrMerged ? 1 : 0;
     const rows = this.database.prepare(
@@ -19165,6 +19171,25 @@ var RvwDatabase = class {
       total: numberValue(totalRow, "total")
     };
   }
+  updatePullRequestGitHubStatuses(updates) {
+    if (updates.length === 0) return;
+    this.immediateTransaction(() => {
+      const statement = this.database.prepare(
+        "UPDATE pull_requests SET github_state = ?, github_is_draft = ? WHERE id = ?"
+      );
+      for (const update of updates) {
+        const result = statement.run(update.state, update.isDraft ? 1 : 0, update.pullRequestId);
+        if (Number(result.changes) !== 1) {
+          throw new RvwError(
+            "PR_NOT_FOUND",
+            `Pull Request\u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093: ${update.pullRequestId}`,
+            { status: 404 }
+          );
+        }
+      }
+      this.incrementChangeSequence();
+    });
+  }
   updateRepositoryLocation(id, repository) {
     this.immediateTransaction(() => {
       const result = this.database.prepare(
@@ -19870,9 +19895,11 @@ import path5 from "node:path";
 import { TextDecoder as TextDecoder2 } from "node:util";
 
 // src/shared/constants.ts
-var APP_VERSION = "0.3.0";
+var APP_VERSION = "0.3.1";
 var PROTOCOL_VERSION = 4;
 var VIEWER_ID_HEADER = "x-rvw-viewer-id";
+var VIEWER_OPEN_LEASE_HEADER = "x-rvw-viewer-open-lease";
+var VIEWER_OPEN_LEASE_QUERY = "viewerLease";
 var GIT_OBJECT_ID_PATTERN = /^[0-9a-f]{40,64}$/i;
 var MAX_TEXT_DOCUMENT_BYTES = 1024 * 1024;
 var MAX_MARKDOWN_ASSET_BYTES = 5 * 1024 * 1024;
@@ -20643,6 +20670,10 @@ var ghPullRequestSchema = external_exports.object({
   headRefOid: external_exports.string().regex(GIT_OBJECT_ID_PATTERN),
   createdAt: external_exports.string()
 });
+var ghPullRequestStatusSchema = external_exports.object({
+  state: external_exports.enum(["OPEN", "CLOSED", "MERGED"]),
+  isDraft: external_exports.boolean()
+});
 function parsePullRequestUrl(url2) {
   const match2 = /^https:\/\/github\.com\/([^/]+)\/([^/]+)\/pull\/(\d+)(?:\/.*)?$/.exec(url2);
   if (!match2?.[1] || !match2[2] || !match2[3]) {
@@ -20663,7 +20694,7 @@ var GitHubClient = class {
     return { version: version2.split("\n")[0] ?? version2, authenticated: auth.exitCode === 0 };
   }
   async assertAuthenticated() {
-    const status = await runProcess("gh", ["auth", "status", "--hostname", "github.com"], {
+    const status = await this.processRunner("gh", ["auth", "status", "--hostname", "github.com"], {
       allowExitCodes: [1]
     });
     if (status.exitCode !== 0) {
@@ -20672,6 +20703,77 @@ var GitHubClient = class {
       });
     }
   }
+  async getPullRequestStatus(reference) {
+    let output;
+    try {
+      const result = await this.processRunner(
+        "gh",
+        ["pr", "view", reference, "--json", "state,isDraft"],
+        { timeoutMs: 6e4 }
+      );
+      output = result.stdout.toString("utf8").trimEnd();
+    } catch (error51) {
+      if (error51 instanceof RvwError && error51.code === "PROCESS_FAILED") {
+        throw new RvwError("GITHUB_ERROR", "Pull Request\u72B6\u614B\u3092GitHub\u304B\u3089\u53D6\u5F97\u3067\u304D\u307E\u305B\u3093\u3067\u3057\u305F\u3002", {
+          cause: error51,
+          details: error51.details,
+          suggestions: ["PR URL\u3068gh\u8A8D\u8A3C\u3092\u78BA\u8A8D\u3057\u3066\u304F\u3060\u3055\u3044\u3002"]
+        });
+      }
+      throw error51;
+    }
+    let decoded;
+    try {
+      decoded = JSON.parse(output);
+    } catch (error51) {
+      throw new RvwError("GITHUB_ERROR", "GitHub CLI\u306EPull Request\u72B6\u614B\u5FDC\u7B54\u304C\u4E0D\u6B63\u3067\u3059\u3002", {
+        cause: error51
+      });
+    }
+    const parsed = ghPullRequestStatusSchema.safeParse(decoded);
+    if (!parsed.success) {
+      throw new RvwError("GITHUB_ERROR", "GitHub CLI\u306EPull Request\u72B6\u614B\u5FDC\u7B54\u304C\u4E0D\u6B63\u3067\u3059\u3002", {
+        details: parsed.error.flatten()
+      });
+    }
+    return parsed.data;
+  }
+  async getPullRequestStatuses(references) {
+    if (references.length === 0) return [];
+    await this.assertAuthenticated();
+    const outcomes = Array.from(
+      { length: references.length },
+      () => void 0
+    );
+    let nextIndex = 0;
+    const workerCount = Math.min(4, references.length);
+    await Promise.all(
+      Array.from({ length: workerCount }, async () => {
+        while (nextIndex < references.length) {
+          const index2 = nextIndex;
+          nextIndex += 1;
+          const reference = references[index2];
+          if (!reference) continue;
+          try {
+            outcomes[index2] = {
+              status: "fulfilled",
+              value: await this.getPullRequestStatus(reference)
+            };
+          } catch (error51) {
+            outcomes[index2] = { status: "rejected", error: error51 };
+          }
+        }
+      })
+    );
+    return outcomes.map((outcome) => {
+      if (!outcome) {
+        throw new RvwError("INTERNAL_ERROR", "Pull Request\u72B6\u614B\u306E\u4E00\u62EC\u53D6\u5F97\u7D50\u679C\u304C\u4E0D\u8DB3\u3057\u3066\u3044\u307E\u3059\u3002", {
+          status: 500
+        });
+      }
+      return outcome;
+    });
+  }
   async getPullRequest(reference, cwd, options = {}) {
     await this.assertAuthenticated();
     const fields = [
@@ -41282,6 +41384,42 @@ var RvwService = class {
       }
     };
   }
+  async refreshPullRequestStatuses() {
+    const pullRequests = this.database.listPullRequestsNeedingStatusRefresh();
+    if (pullRequests.length === 0) {
+      return { attempted: 0, updated: 0, failures: [] };
+    }
+    const outcomes = await this.github.getPullRequestStatuses(
+      pullRequests.map((pullRequest) => pullRequest.url)
+    );
+    if (outcomes.length !== pullRequests.length) {
+      throw new RvwError("GITHUB_ERROR", "Pull Request\u72B6\u614B\u306E\u4E00\u62EC\u53D6\u5F97\u4EF6\u6570\u304C\u4E00\u81F4\u3057\u307E\u305B\u3093\u3002", {
+        status: 502
+      });
+    }
+    const successful = outcomes.flatMap((outcome, index2) => {
+      const pullRequest = pullRequests[index2];
+      return outcome.status === "fulfilled" && pullRequest ? [{ pullRequestId: pullRequest.id, ...outcome.value }] : [];
+    });
+    this.database.updatePullRequestGitHubStatuses(successful);
+    const failures = outcomes.flatMap((outcome, index2) => {
+      const pullRequest = pullRequests[index2];
+      return outcome.status === "rejected" && pullRequest ? [
+        {
+          pullRequestId: pullRequest.id,
+          owner: pullRequest.owner,
+          repository: pullRequest.repository,
+          number: pullRequest.number,
+          error: asRvwError(outcome.error).toJSON()
+        }
+      ] : [];
+    });
+    return {
+      attempted: pullRequests.length,
+      updated: successful.length,
+      failures
+    };
+  }
   resolveStoredPullRequest(reference) {
     if (/^https:\/\/github\.com\//.test(reference)) {
       const parsed = parsePullRequestUrl(reference);
@@ -42639,6 +42777,9 @@ var SkillInstaller = class {
   }
 };
 
+// src/server/start-server.ts
+import { randomUUID as randomUUID4 } from "node:crypto";
+
 // node_modules/.pnpm/@hono+node-server@2.1.0_hono@4.13.1/node_modules/@hono/node-server/dist/constants-BLSFu_RU.mjs
 var X_ALREADY_SENT = "x-hono-already-sent";
 
@@ -46532,7 +46673,11 @@ function createApp(service, options) {
   app.get("/api/meta/change-sequence", (context) => {
     const rawViewerId = context.req.header(VIEWER_ID_HEADER);
     if (rawViewerId !== void 0) {
-      options.viewerLifecycle?.heartbeat(viewerIdSchema.parse(rawViewerId));
+      const rawViewerLease = context.req.header(VIEWER_OPEN_LEASE_HEADER);
+      options.viewerLifecycle?.heartbeat(
+        viewerIdSchema.parse(rawViewerId),
+        rawViewerLease === void 0 ? void 0 : viewerIdSchema.parse(rawViewerLease)
+      );
     }
     return context.json({ ok: true, changeSequence: service.database.getChangeSequence() });
   });
@@ -46560,6 +46705,10 @@ function createApp(service, options) {
     });
     return context.json({ ok: true, ...service.listPullRequests(query) });
   });
+  app.post(
+    "/api/pull-requests/refresh-statuses",
+    async (context) => context.json({ ok: true, ...await service.refreshPullRequestStatuses() })
+  );
   app.get(
     "/api/pull-requests/:id",
     async (context) => context.json({ ok: true, ...await service.getPullRequestView(context.req.param("id")) })
@@ -46837,14 +46986,17 @@ var ViewerLifecycle = class {
   constructor(options) {
     this.options = options;
     this.leaseTimeoutMs = options.leaseTimeoutMs ?? DEFAULT_VIEWER_LEASE_TIMEOUT_MS;
+    this.startupTimeoutMs = options.startupTimeoutMs ?? DEFAULT_VIEWER_STARTUP_TIMEOUT_MS;
     this.closeGraceMs = options.closeGraceMs ?? DEFAULT_VIEWER_CLOSE_GRACE_MS;
     this.timerLatenessToleranceMs = options.timerLatenessToleranceMs ?? DEFAULT_TIMER_LATENESS_TOLERANCE_MS;
   }
   options;
   viewers = /* @__PURE__ */ new Map();
+  pendingViewers = /* @__PURE__ */ new Map();
   // A poll already in flight can arrive after its pagehide release. Keep that document closed.
   releasedViewers = /* @__PURE__ */ new Set();
   leaseTimeoutMs;
+  startupTimeoutMs;
   closeGraceMs;
   timerLatenessToleranceMs;
   timer = null;
@@ -46853,35 +47005,72 @@ var ViewerLifecycle = class {
   get activeViewerCount() {
     return this.viewers.size;
   }
-  heartbeat(viewerId) {
+  get pendingViewerCount() {
+    return this.pendingViewers.size;
+  }
+  reserveViewer(leaseId) {
+    if (this.stopped) return false;
+    this.pendingViewers.set(leaseId, { phase: "opening" });
+    this.scheduleActivityCheck();
+    return true;
+  }
+  armViewerReservation(leaseId) {
+    if (this.stopped || !this.pendingViewers.has(leaseId)) return false;
+    this.pendingViewers.set(leaseId, {
+      phase: "startup",
+      deadline: Date.now() + this.startupTimeoutMs,
+      timeoutMs: this.startupTimeoutMs
+    });
+    this.scheduleActivityCheck();
+    return true;
+  }
+  cancelViewerReservation(leaseId) {
+    if (this.stopped || !this.pendingViewers.delete(leaseId)) return;
+    this.scheduleNext();
+  }
+  heartbeat(viewerId, pendingLeaseId) {
     if (this.stopped || this.releasedViewers.has(viewerId)) return;
+    if (pendingLeaseId !== void 0) this.pendingViewers.delete(pendingLeaseId);
     if (!this.viewerHasConnected) {
       this.viewerHasConnected = true;
       this.options.onFirstViewerConnected?.();
     }
     this.viewers.set(viewerId, Date.now());
-    this.scheduleLeaseCheck();
+    this.scheduleActivityCheck();
   }
   release(viewerId) {
     if (this.stopped) return;
     this.releasedViewers.add(viewerId);
     if (!this.viewers.delete(viewerId)) return;
-    if (this.viewers.size === 0) this.scheduleEmptyShutdown();
-    else this.scheduleLeaseCheck();
+    this.scheduleNext();
   }
   close() {
     this.stopped = true;
     this.clearTimer();
     this.viewers.clear();
+    this.pendingViewers.clear();
     this.releasedViewers.clear();
   }
-  scheduleLeaseCheck() {
-    if (this.stopped || this.viewers.size === 0) return;
-    const earliestHeartbeat = Math.min(...this.viewers.values());
-    this.schedule("lease", earliestHeartbeat + this.leaseTimeoutMs);
+  scheduleNext() {
+    if (this.viewers.size > 0 || this.pendingViewers.size > 0) this.scheduleActivityCheck();
+    else this.scheduleEmptyShutdown();
+  }
+  scheduleActivityCheck() {
+    if (this.stopped) return;
+    const deadlines = [
+      ...Array.from(this.viewers.values(), (heartbeat) => heartbeat + this.leaseTimeoutMs),
+      ...Array.from(this.pendingViewers.values()).filter(
+        (pending) => pending.phase === "startup"
+      ).map((pending) => pending.deadline)
+    ];
+    if (deadlines.length === 0) {
+      this.clearTimer();
+      return;
+    }
+    this.schedule("activity", Math.min(...deadlines));
   }
   scheduleEmptyShutdown() {
-    if (this.stopped || this.viewers.size > 0) return;
+    if (this.stopped || this.viewers.size > 0 || this.pendingViewers.size > 0) return;
     this.schedule("empty", Date.now() + this.closeGraceMs);
   }
   schedule(kind, deadline) {
@@ -46895,23 +47084,33 @@ var ViewerLifecycle = class {
     const now = Date.now();
     if (now - deadline > this.timerLatenessToleranceMs) {
       for (const viewerId of this.viewers.keys()) this.viewers.set(viewerId, now);
-      if (this.viewers.size === 0) this.scheduleEmptyShutdown();
-      else this.scheduleLeaseCheck();
+      for (const [leaseId, pending] of this.pendingViewers) {
+        if (pending.phase !== "startup") continue;
+        this.pendingViewers.set(leaseId, {
+          phase: "startup",
+          deadline: now + pending.timeoutMs,
+          timeoutMs: pending.timeoutMs
+        });
+      }
+      this.scheduleNext();
       return;
     }
-    if (kind === "lease") {
+    if (kind === "activity") {
       for (const [viewerId, lastHeartbeat] of this.viewers) {
         if (now - lastHeartbeat >= this.leaseTimeoutMs) this.viewers.delete(viewerId);
       }
-      if (this.viewers.size > 0) this.scheduleLeaseCheck();
-      else this.scheduleEmptyShutdown();
+      for (const [leaseId, pending] of this.pendingViewers) {
+        if (pending.phase !== "startup") continue;
+        if (now >= pending.deadline) this.pendingViewers.delete(leaseId);
+      }
+      this.scheduleNext();
       return;
     }
-    if (this.viewers.size === 0) {
+    if (this.viewers.size === 0 && this.pendingViewers.size === 0) {
       this.stopped = true;
       this.options.onAllViewersClosed();
     } else {
-      this.scheduleLeaseCheck();
+      this.scheduleActivityCheck();
     }
   }
   clearTimer() {
@@ -46921,6 +47120,7 @@ var ViewerLifecycle = class {
 };
 
 // src/server/start-server.ts
+var RUNTIME_STOPPING_REASON = "runtime-stopping";
 async function startServer(service, options = {}) {
   const host = "127.0.0.1";
   const security = { expectedHost: null, expectedOrigin: null };
@@ -46960,6 +47160,33 @@ async function startServer(service, options = {}) {
           origin,
           firstViewerConnected,
           allViewersClosed,
+          reserveViewer: () => {
+            if (!viewerLifecycle) return null;
+            const leaseId = randomUUID4();
+            if (!viewerLifecycle.reserveViewer(leaseId)) {
+              throw new RvwError(
+                "PROCESS_FAILED",
+                "rvw runtime\u306F\u505C\u6B62\u51E6\u7406\u4E2D\u306E\u305F\u3081viewer\u3092\u8FFD\u52A0\u3067\u304D\u307E\u305B\u3093\u3002",
+                {
+                  details: { reason: RUNTIME_STOPPING_REASON },
+                  suggestions: ["rvw open\u3092\u518D\u5B9F\u884C\u3057\u3066\u304F\u3060\u3055\u3044\u3002"]
+                }
+              );
+            }
+            return leaseId;
+          },
+          armViewerReservation: (leaseId) => {
+            if (!viewerLifecycle || viewerLifecycle.armViewerReservation(leaseId)) return;
+            throw new RvwError(
+              "PROCESS_FAILED",
+              "rvw runtime\u306F\u505C\u6B62\u51E6\u7406\u4E2D\u306E\u305F\u3081viewer\u3092\u8FFD\u52A0\u3067\u304D\u307E\u305B\u3093\u3002",
+              {
+                details: { reason: RUNTIME_STOPPING_REASON },
+                suggestions: ["rvw open\u3092\u518D\u5B9F\u884C\u3057\u3066\u304F\u3060\u3055\u3044\u3002"]
+              }
+            );
+          },
+          cancelViewerReservation: (leaseId) => viewerLifecycle?.cancelViewerReservation(leaseId),
           close: () => closePromise ??= (async () => {
             viewerLifecycle?.close();
             await new Promise((closeResolve, closeReject) => {
@@ -46974,7 +47201,7 @@ async function startServer(service, options = {}) {
 }
 
 // src/server/agent-socket.ts
-import { createHash as createHash5, randomUUID as randomUUID4 } from "node:crypto";
+import { createHash as createHash5, randomUUID as randomUUID5 } from "node:crypto";
 import {
   chmodSync as chmodSync2,
   existsSync as existsSync5,
@@ -46990,7 +47217,8 @@ import os4 from "node:os";
 import path9 from "node:path";
 var MAX_CLI_STDIN_BYTES = 40 * 1024 * 1024;
 var MAX_AGENT_MESSAGE_BYTES = MAX_CLI_STDIN_BYTES + 64 * 1024;
-var AGENT_SOCKET_PROTOCOL_VERSION = 2;
+var AGENT_SOCKET_PROTOCOL_VERSION = 4;
+var RUNTIME_VIEWER_OPEN_OPERATION = "viewer.open";
 var AGENT_SOCKET_RESTART_SUGGESTION = "\u8D77\u52D5\u4E2D\u306Ervw viewer\u3092\u505C\u6B62\u3057\u3001\u66F4\u65B0\u5F8C\u306Ervw open\u3067\u518D\u8D77\u52D5\u3057\u3066\u304F\u3060\u3055\u3044\u3002";
 var DEFAULT_CONNECT_TIMEOUT_MS = 2e3;
 var DEFAULT_OPERATION_TIMEOUT_MS = 18e4;
@@ -47003,6 +47231,19 @@ var agentRequestEnvelopeSchema = external_exports.object({
   input: external_exports.unknown(),
   expectedDatabasePath: external_exports.string().min(1).optional()
 }).strict();
+var runtimeViewerOpenInputSchema = external_exports.object({
+  reference: external_exports.string().min(1).optional(),
+  cwd: external_exports.string().min(1),
+  requestedPort: external_exports.number().int().min(0).max(65535)
+}).strict();
+var runtimeViewerOpenResultSchema = external_exports.object({
+  url: external_exports.string().url(),
+  origin: external_exports.string().url(),
+  port: external_exports.number().int().min(1).max(65535),
+  pullRequestId: external_exports.string().min(1),
+  ownerPid: external_exports.number().int().positive(),
+  viewerLeaseId: external_exports.uuid().optional()
+}).strict();
 function explicitAgentSocketPath() {
   const configuredPath = process.env.RVW_AGENT_SOCKET_PATH;
   if (configuredPath === void 0) return null;
@@ -47058,7 +47299,10 @@ function parseOperationInput(operation, value) {
   if (!parsed.success) throw invalidSocketInput(parsed.error);
   return parsed.data;
 }
-async function dispatchAgentSocketRequest(service, rawRequest) {
+function resolveDatabaseIdentity(databaseFilePath) {
+  return databaseFilePath === ":memory:" ? databaseFilePath : path9.resolve(databaseFilePath);
+}
+function validateAgentRequest(rawRequest, databaseFilePath) {
   const request = parseRequest(rawRequest);
   if (request.protocolVersion !== AGENT_SOCKET_PROTOCOL_VERSION) {
     throw new RvwError("STALE_PROTOCOL", "Agent socket protocol version\u304C\u4E00\u81F4\u3057\u307E\u305B\u3093\u3002", {
@@ -47069,23 +47313,30 @@ async function dispatchAgentSocketRequest(service, rawRequest) {
       suggestions: [AGENT_SOCKET_RESTART_SUGGESTION]
     });
   }
-  if (request.expectedDatabasePath !== void 0 && path9.resolve(request.expectedDatabasePath) !== path9.resolve(service.database.filePath)) {
+  if (request.expectedDatabasePath !== void 0 && databaseFilePath !== void 0 && resolveDatabaseIdentity(request.expectedDatabasePath) !== resolveDatabaseIdentity(databaseFilePath)) {
     throw new RvwError("DATABASE_ERROR", "Agent socket\u304C\u5225\u306Edatabase\u3092\u4F7F\u7528\u3057\u3066\u3044\u307E\u3059\u3002", {
       details: {
         agentSocketDatabaseMismatch: true,
-        expectedDatabasePath: path9.resolve(request.expectedDatabasePath),
-        actualDatabasePath: path9.resolve(service.database.filePath)
+        expectedDatabasePath: resolveDatabaseIdentity(request.expectedDatabasePath),
+        actualDatabasePath: resolveDatabaseIdentity(databaseFilePath)
       }
     });
   }
+  return request;
+}
+function pingResult(databaseFilePath) {
+  return {
+    protocolVersion: AGENT_SOCKET_PROTOCOL_VERSION,
+    databasePath: resolveDatabaseIdentity(databaseFilePath),
+    ownerPid: process.pid
+  };
+}
+async function dispatchAgentSocketRequest(service, rawRequest) {
+  const request = validateAgentRequest(rawRequest, service.database?.filePath);
   if (request.operation === "ping") {
     const ping = external_exports.object({}).strict().safeParse(request.input);
     if (!ping.success) throw invalidSocketInput(ping.error);
-    return {
-      protocolVersion: AGENT_SOCKET_PROTOCOL_VERSION,
-      databasePath: path9.resolve(service.database.filePath),
-      ownerPid: process.pid
-    };
+    return pingResult(service.database.filePath);
   }
   if (!Object.hasOwn(agentCommandInputSchemas, request.operation)) {
     throw new RvwError("INVALID_INPUT", `\u672A\u5BFE\u5FDC\u306EAgent socket operation\u3067\u3059: ${request.operation}`);
@@ -47390,6 +47641,38 @@ async function tryAgentSocketRequest(operation, input, options = {}) {
     });
   });
 }
+async function tryRuntimeViewerOpen(input, databaseFilePath = databasePathConfiguration().filePath, options = {}) {
+  const parsedInput = runtimeViewerOpenInputSchema.safeParse(input);
+  if (!parsedInput.success) throw invalidSocketInput(parsedInput.error);
+  const response = await tryAgentSocketRequest(
+    RUNTIME_VIEWER_OPEN_OPERATION,
+    parsedInput.data,
+    {
+      expectedDatabasePath: databaseFilePath,
+      requireSocket: false,
+      ...options
+    }
+  );
+  if (!response.available) return response;
+  const parsedResult = runtimeViewerOpenResultSchema.safeParse(response.result);
+  if (!parsedResult.success) {
+    throw new RvwError("PROCESS_FAILED", "\u8D77\u52D5\u4E2D\u306Ervw runtime\u304B\u3089\u4E0D\u6B63\u306A\u5FDC\u7B54\u3092\u53D7\u4FE1\u3057\u307E\u3057\u305F\u3002", {
+      details: { issues: parsedResult.error.issues },
+      suggestions: [AGENT_SOCKET_RESTART_SUGGESTION]
+    });
+  }
+  return {
+    available: true,
+    result: {
+      url: parsedResult.data.url,
+      origin: parsedResult.data.origin,
+      port: parsedResult.data.port,
+      pullRequestId: parsedResult.data.pullRequestId,
+      ownerPid: parsedResult.data.ownerPid,
+      ...parsedResult.data.viewerLeaseId === void 0 ? {} : { viewerLeaseId: parsedResult.data.viewerLeaseId }
+    }
+  };
+}
 async function inspectAgentTransport(databaseFilePath = databasePathConfiguration().filePath) {
   const expectedDatabasePath = databaseFilePath === ":memory:" ? databaseFilePath : path9.resolve(databaseFilePath);
   const configuredSocketPath = explicitAgentSocketPath();
@@ -47492,7 +47775,7 @@ function socketOwnerPid(lockPath) {
 function tryAcquireSocketOwnerLock(socketPath) {
   const lockPath = `${socketPath}${OWNER_LOCK_SUFFIX}`;
   for (let attempt = 0; attempt < 2; attempt += 1) {
-    const stagingPath = `${lockPath}.${process.pid}.${randomUUID4()}.tmp`;
+    const stagingPath = `${lockPath}.${process.pid}.${randomUUID5()}.tmp`;
     try {
       writeFileSync2(stagingPath, `${JSON.stringify({ pid: process.pid })}
 `, {
@@ -47536,7 +47819,7 @@ function releaseSocketOwnerLock(lock) {
   if (!lock) return;
   unlinkIfOwned(lock.path, lock.identity);
 }
-function createAgentServer(service) {
+function createAgentServer(dispatch) {
   const server = net.createServer((socket) => {
     const chunks = [];
     let bytes = 0;
@@ -47561,7 +47844,7 @@ function createAgentServer(service) {
           const request = JSON.parse(Buffer.concat(chunks).toString("utf8"));
           response = {
             ok: true,
-            result: await dispatchAgentSocketRequest(service, parseRequest(request))
+            result: await dispatch(parseRequest(request))
           };
         } catch (error51) {
           response = { ok: false, error: asRvwError(error51).toJSON() };
@@ -47589,8 +47872,8 @@ async function listen(server, socketPath) {
     server.listen(socketPath);
   });
 }
-async function startAgentSocket(service, options = {}) {
-  const socketPath = agentSocketPath(service.database.filePath);
+async function startAgentSocketListener(databaseFilePath, dispatch, options) {
+  const socketPath = agentSocketPath(databaseFilePath);
   ensurePrivateSocketDirectory(socketPath);
   const retryDelay = options.takeoverRetryMs ?? DEFAULT_TAKEOVER_RETRY_MS;
   let server = null;
@@ -47598,9 +47881,12 @@ async function startAgentSocket(service, options = {}) {
   let ownerLock = null;
   let retryTimer;
   let acquisition = null;
+  let listenerDrain = null;
+  let stopPromise = null;
+  let releasePromise = null;
   let closed = false;
   const scheduleTakeover = () => {
-    if (closed || server || retryTimer) return;
+    if (!options.retryOwnership || closed || server || retryTimer) return;
     retryTimer = setTimeout(() => {
       retryTimer = void 0;
       void acquire().catch(() => scheduleTakeover());
@@ -47629,7 +47915,7 @@ async function startAgentSocket(service, options = {}) {
           throw error51;
         }
       }
-      const candidate = createAgentServer(service);
+      const candidate = createAgentServer(dispatch);
       try {
         await listen(candidate, socketPath);
       } catch (error51) {
@@ -47661,12 +47947,16 @@ async function startAgentSocket(service, options = {}) {
       ownerLock = candidateLock;
       candidate.on("error", () => {
         if (server !== candidate) return;
-        const failedIdentity = identity;
-        const failedOwnerLock = ownerLock;
         server = null;
+        listenerDrain = new Promise((resolve) => candidate.close(() => resolve()));
+        if (!options.retryOwnership) {
+          return;
+        }
+        const failedIdentity = identity;
         identity = null;
+        const failedOwnerLock = ownerLock;
         ownerLock = null;
-        candidate.close(() => {
+        void listenerDrain.then(() => {
           unlinkIfOwned(socketPath, failedIdentity);
           releaseSocketOwnerLock(failedOwnerLock);
           scheduleTakeover();
@@ -47680,33 +47970,128 @@ async function startAgentSocket(service, options = {}) {
     }
   };
   await acquire();
-  return {
-    path: socketPath,
-    get owned() {
-      return server !== null;
-    },
-    close: async () => {
+  const stopAccepting = async () => {
+    await (stopPromise ??= (async () => {
       closed = true;
       if (retryTimer) clearTimeout(retryTimer);
       await acquisition;
+      if (listenerDrain) await listenerDrain;
       const ownedServer = server;
-      const ownedIdentity = identity;
-      const ownedOwnerLock = ownerLock;
       server = null;
-      identity = null;
-      ownerLock = null;
-      if (!ownedServer) {
-        releaseSocketOwnerLock(ownedOwnerLock);
-        return;
-      }
+      if (!ownedServer) return;
+      listenerDrain = new Promise(
+        (resolve, reject) => ownedServer.close((error51) => error51 ? reject(error51) : resolve())
+      );
+      await listenerDrain;
+    })());
+  };
+  const releaseOwnership = async () => {
+    await (releasePromise ??= (async () => {
       try {
-        await new Promise(
-          (resolve, reject) => ownedServer.close((error51) => error51 ? reject(error51) : resolve())
-        );
+        await stopAccepting();
       } finally {
-        unlinkIfOwned(socketPath, ownedIdentity);
-        releaseSocketOwnerLock(ownedOwnerLock);
+        const ownedIdentity = identity;
+        const ownedOwnerLock = ownerLock;
+        identity = null;
+        ownerLock = null;
+        try {
+          unlinkIfOwned(socketPath, ownedIdentity);
+        } finally {
+          releaseSocketOwnerLock(ownedOwnerLock);
+        }
+      }
+    })());
+  };
+  return {
+    path: socketPath,
+    get owned() {
+      return ownerLock !== null;
+    },
+    stopAccepting,
+    releaseOwnership,
+    close: releaseOwnership
+  };
+}
+async function startRuntimeAgentSocket(databaseFilePath) {
+  let handler = null;
+  let resolveHandler;
+  let rejectHandler;
+  const handlerPromise = new Promise((resolve, reject) => {
+    resolveHandler = resolve;
+    rejectHandler = reject;
+  });
+  void handlerPromise.catch(() => {
+  });
+  let accepting = true;
+  const rejectUninitializedHandler = () => {
+    if (handler) return;
+    rejectHandler?.(new RvwError("PROCESS_FAILED", "rvw runtime\u304C\u521D\u671F\u5316\u3055\u308C\u308B\u524D\u306B\u505C\u6B62\u3057\u307E\u3057\u305F\u3002"));
+    resolveHandler = void 0;
+    rejectHandler = void 0;
+  };
+  const running = await startAgentSocketListener(
+    databaseFilePath,
+    async (rawRequest) => {
+      const request = validateAgentRequest(rawRequest, databaseFilePath);
+      if (request.operation === "ping") {
+        const ping = external_exports.object({}).strict().safeParse(request.input);
+        if (!ping.success) throw invalidSocketInput(ping.error);
+        return pingResult(databaseFilePath);
+      }
+      if (request.operation === RUNTIME_VIEWER_OPEN_OPERATION) {
+        const parsed = runtimeViewerOpenInputSchema.safeParse(request.input);
+        if (!parsed.success) throw invalidSocketInput(parsed.error);
+        return await (await handlerPromise).openViewer({
+          ...parsed.data.reference === void 0 ? {} : { reference: parsed.data.reference },
+          cwd: parsed.data.cwd,
+          requestedPort: parsed.data.requestedPort
+        });
+      }
+      return await dispatchAgentSocketRequest((await handlerPromise).service, request);
+    },
+    { retryOwnership: false }
+  );
+  return {
+    path: running.path,
+    get owned() {
+      return running.owned;
+    },
+    setHandler(value) {
+      if (!running.owned || !accepting) {
+        throw new RvwError("PROCESS_FAILED", "\u6240\u6709\u3057\u3066\u3044\u306A\u3044runtime socket\u306F\u521D\u671F\u5316\u3067\u304D\u307E\u305B\u3093\u3002");
       }
+      if (handler) {
+        throw new RvwError("INTERNAL_ERROR", "runtime socket\u306F\u521D\u671F\u5316\u6E08\u307F\u3067\u3059\u3002", {
+          status: 500
+        });
+      }
+      if (resolveDatabaseIdentity(value.service.database.filePath) !== resolveDatabaseIdentity(databaseFilePath)) {
+        throw new RvwError("DATABASE_ERROR", "runtime\u3068Agent socket\u306Edatabase\u304C\u4E00\u81F4\u3057\u307E\u305B\u3093\u3002", {
+          details: {
+            socketDatabasePath: resolveDatabaseIdentity(databaseFilePath),
+            runtimeDatabasePath: resolveDatabaseIdentity(value.service.database.filePath)
+          }
+        });
+      }
+      handler = value;
+      resolveHandler?.(value);
+      resolveHandler = void 0;
+      rejectHandler = void 0;
+    },
+    stopAccepting: async () => {
+      accepting = false;
+      rejectUninitializedHandler();
+      await running.stopAccepting();
+    },
+    releaseOwnership: async () => {
+      accepting = false;
+      rejectUninitializedHandler();
+      await running.releaseOwnership();
+    },
+    close: async () => {
+      accepting = false;
+      rejectUninitializedHandler();
+      await running.releaseOwnership();
     }
   };
 }
@@ -48067,6 +48452,9 @@ function formatCommentListOutput(result, state) {
 var MAX_STDIN_BYTES = MAX_CLI_STDIN_BYTES;
 var OPEN_WORKER_READY_TIMEOUT_MS = 12e4;
 var OPEN_WORKER_PARENT_TIMEOUT_PADDING_MS = 5e3;
+var RUNTIME_REUSE_RETRY_MS = 50;
+var RUNTIME_VIEWER_HEARTBEAT_INTERVAL_MS = 3e4;
+var RUNTIME_VIEWER_REQUEST_TIMEOUT_MS = 5e3;
 function writeJson(value) {
   process.stdout.write(`${JSON.stringify(value)}
 `);
@@ -48162,6 +48550,11 @@ function errorFromOpenWorker(error51) {
     ...error51.details === void 0 ? {} : { details: error51.details }
   });
 }
+function isRuntimeStoppingError(error51) {
+  if (!(error51 instanceof RvwError) || error51.code !== "PROCESS_FAILED") return false;
+  if (!error51.details || typeof error51.details !== "object") return false;
+  return error51.details.reason === RUNTIME_STOPPING_REASON;
+}
 async function completeBackgroundOpen(child, launchBrowser, options = {}) {
   const readyTimeoutMs = options.readyTimeoutMs ?? OPEN_WORKER_READY_TIMEOUT_MS;
   const viewerTimeoutMs = options.viewerTimeoutMs ?? DEFAULT_VIEWER_STARTUP_TIMEOUT_MS + OPEN_WORKER_PARENT_TIMEOUT_PADDING_MS;
@@ -48285,11 +48678,31 @@ function forkOpenWorker(reference, port) {
   });
 }
 async function startBackgroundOpen(reference, port, dependencies = {}) {
+  const input = {
+    ...reference === void 0 ? {} : { reference },
+    cwd: process.cwd(),
+    requestedPort: port
+  };
+  const launchBrowser = dependencies.launchBrowser ?? (async (url2) => await open_default(url2));
+  let existing = null;
+  try {
+    existing = await (dependencies.tryRuntimeOpen ?? tryRuntimeViewerOpen)(input);
+  } catch (error51) {
+    if (!isRuntimeStoppingError(error51)) throw error51;
+  }
+  if (existing?.available) {
+    await launchBrowser(existing.result.url);
+    return existing.result.url;
+  }
+  if (existing?.reason === "database-mismatch") {
+    throw new RvwError(
+      "AGENT_SOCKET_UNAVAILABLE",
+      "\u8D77\u52D5\u4E2D\u306Ervw runtime\u304C\u5225\u306Edatabase\u3092\u4F7F\u7528\u3057\u3066\u3044\u307E\u3059\u3002",
+      { details: existing.details }
+    );
+  }
   const child = (dependencies.forkWorker ?? forkOpenWorker)(reference, port);
-  return await completeBackgroundOpen(
-    child,
-    dependencies.launchBrowser ?? (async (url2) => await open_default(url2))
-  );
+  return await completeBackgroundOpen(child, launchBrowser);
 }
 async function sendOpenWorkerMessage(message) {
   if (!process.send || !process.connected) return false;
@@ -48321,17 +48734,208 @@ async function waitForInitialViewer(firstViewerConnected, timeoutMs = DEFAULT_VI
     void firstViewerConnected.then(() => finish("connected"));
   });
 }
-async function runOpenServer(activeRuntime, reference, port, openAutomatically, useAgentSocket) {
+function runtimeViewerOpenInput(reference, cwd, requestedPort) {
+  return {
+    ...reference === void 0 ? {} : { reference },
+    cwd,
+    requestedPort
+  };
+}
+function createRuntimeAgentSocketHandler(activeRuntime, running) {
+  return {
+    service: activeRuntime.service,
+    openViewer: async (input) => {
+      if (input.requestedPort !== 0 && input.requestedPort !== running.port) {
+        throw new RvwError(
+          "INVALID_INPUT",
+          `\u540C\u3058database\u306Ervw runtime\u306Fport ${running.port} \u3067\u8D77\u52D5\u6E08\u307F\u3067\u3059\u3002`,
+          {
+            details: { activePort: running.port, requestedPort: input.requestedPort },
+            suggestions: [
+              "\u65E2\u5B58runtime\u3092\u505C\u6B62\u3057\u3066\u304B\u3089\u6307\u5B9Aport\u3067\u518D\u8D77\u52D5\u3059\u308B\u304B\u3001--port\u3092\u7701\u7565\u3057\u3066\u304F\u3060\u3055\u3044\u3002"
+            ]
+          }
+        );
+      }
+      const viewerLeaseId = running.reserveViewer();
+      try {
+        const opened = await activeRuntime.service.openPullRequest(input.reference, input.cwd);
+        if (viewerLeaseId !== null) running.armViewerReservation(viewerLeaseId);
+        const url2 = new URL(running.origin);
+        url2.searchParams.set("pullRequestId", opened.pullRequest.id);
+        if (viewerLeaseId !== null) url2.searchParams.set(VIEWER_OPEN_LEASE_QUERY, viewerLeaseId);
+        return {
+          url: url2.toString(),
+          origin: running.origin,
+          port: running.port,
+          pullRequestId: opened.pullRequest.id,
+          ownerPid: process.pid,
+          ...viewerLeaseId === null ? {} : { viewerLeaseId }
+        };
+      } catch (error51) {
+        if (viewerLeaseId !== null) running.cancelViewerReservation(viewerLeaseId);
+        throw error51;
+      }
+    }
+  };
+}
+async function holdRuntimeViewerLease(result, dependencies = {}) {
+  const viewerLeaseId = result.viewerLeaseId;
+  if (viewerLeaseId === void 0) return;
+  const fetchRequest = dependencies.fetch ?? fetch;
+  const viewerId = randomUUID6();
+  const requestTimeoutMs = dependencies.requestTimeoutMs ?? RUNTIME_VIEWER_REQUEST_TIMEOUT_MS;
+  const heartbeatUrl = new URL("/api/meta/change-sequence", result.origin);
+  const releaseUrl = new URL("/api/meta/viewers/release", result.origin);
+  const heartbeat = async () => {
+    const response = await fetchRequest(heartbeatUrl, {
+      signal: AbortSignal.timeout(requestTimeoutMs),
+      headers: {
+        [VIEWER_ID_HEADER]: viewerId,
+        [VIEWER_OPEN_LEASE_HEADER]: viewerLeaseId
+      }
+    });
+    if (!response.ok) {
+      throw new RvwError("PROCESS_FAILED", "rvw runtime\u306Eviewer lease\u3092\u66F4\u65B0\u3067\u304D\u307E\u305B\u3093\u3067\u3057\u305F\u3002", {
+        details: { status: response.status, origin: result.origin }
+      });
+    }
+  };
+  const stopped = Promise.withResolvers();
+  let heartbeatError;
+  let heartbeatInFlight = false;
+  const onSignal = () => stopped.resolve("signal");
+  process.once("SIGINT", onSignal);
+  process.once("SIGTERM", onSignal);
+  let interval;
+  let registered = false;
+  try {
+    await heartbeat();
+    registered = true;
+    interval = setInterval(() => {
+      if (heartbeatInFlight) return;
+      heartbeatInFlight = true;
+      void heartbeat().catch((error51) => {
+        heartbeatError = error51;
+        stopped.resolve("heartbeat-failed");
+      }).finally(() => {
+        heartbeatInFlight = false;
+      });
+    }, dependencies.heartbeatIntervalMs ?? RUNTIME_VIEWER_HEARTBEAT_INTERVAL_MS);
+    interval.unref();
+    const reason = await stopped.promise;
+    if (reason === "heartbeat-failed") throw heartbeatError;
+  } finally {
+    if (interval) clearInterval(interval);
+    process.removeListener("SIGINT", onSignal);
+    process.removeListener("SIGTERM", onSignal);
+    if (registered) {
+      await fetchRequest(releaseUrl, {
+        method: "POST",
+        signal: AbortSignal.timeout(requestTimeoutMs),
+        headers: {
+          origin: result.origin,
+          "content-type": "application/json"
+        },
+        body: JSON.stringify({ viewerId })
+      }).catch(() => void 0);
+    }
+  }
+}
+async function closeOwnedRuntime(agentSocket, running, activeRuntime) {
+  try {
+    await agentSocket?.stopAccepting();
+  } finally {
+    try {
+      await running?.close();
+    } finally {
+      try {
+        activeRuntime?.close();
+      } finally {
+        await agentSocket?.releaseOwnership();
+      }
+    }
+  }
+}
+async function acquireRuntimeOrReuseExisting(input, databaseFilePath, timeoutMs = OPEN_WORKER_READY_TIMEOUT_MS, dependencies = {}) {
+  const startSocket = dependencies.startSocket ?? startRuntimeAgentSocket;
+  const tryRuntimeOpen = dependencies.tryRuntimeOpen ?? tryRuntimeViewerOpen;
+  const wait = dependencies.wait ?? (async (milliseconds) => {
+    await new Promise((resolve) => setTimeout(resolve, milliseconds));
+  });
+  const now = dependencies.now ?? Date.now;
+  const deadline = now() + timeoutMs;
+  do {
+    const candidate = await startSocket(databaseFilePath);
+    if (candidate.owned) return { kind: "owned", agentSocket: candidate };
+    await candidate.close();
+    let response = null;
+    try {
+      response = await tryRuntimeOpen(input, databaseFilePath);
+    } catch (error51) {
+      if (!isRuntimeStoppingError(error51)) throw error51;
+    }
+    if (response?.available) return { kind: "reused", result: response.result };
+    if (response?.reason === "database-mismatch") {
+      throw new RvwError(
+        "AGENT_SOCKET_UNAVAILABLE",
+        "\u8D77\u52D5\u4E2D\u306Ervw runtime\u304C\u5225\u306Edatabase\u3092\u4F7F\u7528\u3057\u3066\u3044\u307E\u3059\u3002",
+        { details: response.details }
+      );
+    }
+    await wait(RUNTIME_REUSE_RETRY_MS);
+  } while (now() < deadline);
+  throw new RvwError("PROCESS_TIMEOUT", "\u8D77\u52D5\u4E2D\u306Ervw runtime\u3078\u306E\u63A5\u7D9A\u304C\u30BF\u30A4\u30E0\u30A2\u30A6\u30C8\u3057\u307E\u3057\u305F\u3002", {
+    details: { timeoutMs }
+  });
+}
+async function waitForWorkerParentDisconnect() {
+  if (!process.connected) return;
+  await new Promise((resolve) => process.once("disconnect", resolve));
+}
+async function runOpenServer(runtimeFactory, reference, port, openAutomatically, useAgentSocket, reuseExisting) {
+  let activeRuntime;
   let running;
   let agentSocket;
   try {
+    if (useAgentSocket) {
+      const databaseFilePath = databasePathConfiguration().filePath;
+      if (reuseExisting) {
+        const startup = await acquireRuntimeOrReuseExisting(
+          runtimeViewerOpenInput(reference, process.cwd(), port),
+          databaseFilePath
+        );
+        if (startup.kind === "reused") {
+          const result = startup.result;
+          process.stdout.write(`rvw: ${result.url}
+`);
+          if (!openAutomatically) await holdRuntimeViewerLease(result);
+          return;
+        }
+        agentSocket = startup.agentSocket;
+      } else {
+        agentSocket = await startRuntimeAgentSocket(databaseFilePath);
+        if (!agentSocket.owned) {
+          throw new RvwError(
+            "PROCESS_FAILED",
+            "\u540C\u3058database\u306Ervw runtime\u304C\u65E2\u306B\u8D77\u52D5\u4E2D\u306E\u305F\u3081foreground server\u3092\u958B\u59CB\u3067\u304D\u307E\u305B\u3093\u3002",
+            {
+              suggestions: [
+                "\u901A\u5E38\u306Ervw open\u3067\u65E2\u5B58runtime\u3092\u5229\u7528\u3059\u308B\u304B\u3001\u65E2\u5B58runtime\u3092\u505C\u6B62\u3057\u3066\u304B\u3089\u518D\u5B9F\u884C\u3057\u3066\u304F\u3060\u3055\u3044\u3002"
+              ]
+            }
+          );
+        }
+      }
+    }
+    activeRuntime = runtimeFactory();
     const opened = await activeRuntime.service.openPullRequest(reference, process.cwd());
     running = await startServer(activeRuntime.service, {
       port,
       staticDirectory: staticDirectory(),
       autoCloseWhenNoViewers: openAutomatically
     });
-    if (useAgentSocket) agentSocket = await startAgentSocket(activeRuntime.service);
+    agentSocket?.setHandler(createRuntimeAgentSocketHandler(activeRuntime, running));
     const url2 = new URL(running.origin);
     url2.searchParams.set("pullRequestId", opened.pullRequest.id);
     process.stdout.write(`rvw: ${url2.toString()}
@@ -48342,31 +48946,38 @@ async function runOpenServer(activeRuntime, reference, port, openAutomatically,
       process.stdout.write("rvw: viewer\u3092\u9589\u3058\u305F\u305F\u3081server\u3092\u505C\u6B62\u3057\u307E\u3059\u3002\n");
     }
   } finally {
-    try {
-      await agentSocket?.close();
-    } finally {
-      try {
-        await running?.close();
-      } finally {
-        activeRuntime.close();
-      }
-    }
+    await closeOwnedRuntime(agentSocket, running, activeRuntime);
   }
 }
-async function runOpenWorker(activeRuntime, reference, port) {
+async function runOpenWorker(runtimeFactory, reference, port) {
+  let activeRuntime;
   let running;
   let agentSocket;
   try {
     if (!process.send || !process.connected) {
       throw new RvwError("INVALID_INPUT", "\u5185\u90E8viewer worker\u306F\u89AACLI\u304B\u3089\u8D77\u52D5\u3057\u3066\u304F\u3060\u3055\u3044\u3002");
     }
+    const databaseFilePath = databasePathConfiguration().filePath;
+    const startup = await acquireRuntimeOrReuseExisting(
+      runtimeViewerOpenInput(reference, process.cwd(), port),
+      databaseFilePath
+    );
+    if (startup.kind === "reused") {
+      const result = startup.result;
+      if (!await sendOpenWorkerMessage({ type: "ready", url: result.url })) return;
+      if (!await sendOpenWorkerMessage({ type: "viewer-connected" })) return;
+      await waitForWorkerParentDisconnect();
+      return;
+    }
+    agentSocket = startup.agentSocket;
+    activeRuntime = runtimeFactory();
     const opened = await activeRuntime.service.openPullRequest(reference, process.cwd());
     running = await startServer(activeRuntime.service, {
       port,
       staticDirectory: staticDirectory(),
       autoCloseWhenNoViewers: true
     });
-    agentSocket = await startAgentSocket(activeRuntime.service);
+    agentSocket.setHandler(createRuntimeAgentSocketHandler(activeRuntime, running));
     const url2 = new URL(running.origin);
     url2.searchParams.set("pullRequestId", opened.pullRequest.id);
     if (!await sendOpenWorkerMessage({ type: "ready", url: url2.toString() })) return;
@@ -48386,15 +48997,7 @@ async function runOpenWorker(activeRuntime, reference, port) {
     await sendOpenWorkerMessage({ type: "viewer-connected" });
     await waitForServerShutdown(running.allViewersClosed);
   } finally {
-    try {
-      await agentSocket?.close();
-    } finally {
-      try {
-        await running?.close();
-      } finally {
-        activeRuntime.close();
-      }
-    }
+    await closeOwnedRuntime(agentSocket, running, activeRuntime);
   }
 }
 var defaultRuntimeFactory = () => createRuntime();
@@ -48495,12 +49098,19 @@ function createProgram(runtimeFactory = defaultRuntimeFactory) {
 `);
         return;
       }
-      await runOpenServer(getRuntime(), reference, options.port, options.open, useAgentSocket);
+      await runOpenServer(
+        getRuntime,
+        reference,
+        options.port,
+        options.open,
+        useAgentSocket,
+        !options.foreground
+      );
     }
   );
   program2.command("__open-worker", { hidden: true }).option("--reference <pull-request>").requiredOption("--port <port>", "listen port", parsePort).action(async (options) => {
     try {
-      await runOpenWorker(getRuntime(), options.reference, options.port);
+      await runOpenWorker(getRuntime, options.reference, options.port);
     } catch (error51) {
       const rvwError = asRvwError(error51);
       const sent = await sendOpenWorkerMessage({
@@ -48861,8 +49471,12 @@ if (bundledCli || process.argv[1] && import.meta.url === pathToFileURL(process.a
   await runCli();
 }
 export {
+  acquireRuntimeOrReuseExisting,
+  closeOwnedRuntime,
   completeBackgroundOpen,
   createProgram,
+  createRuntimeAgentSocketHandler,
+  holdRuntimeViewerLease,
   runCli,
   startBackgroundOpen,
   waitForServerShutdown