@a9n-shoji/rvw 0.3.0 → 0.3.2

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.2";
 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;
@@ -20369,6 +20396,10 @@ var GitClient = class {
     );
     return parseCommitLog(output);
   }
+  async firstParent(cwd, oid) {
+    const parents = await runText("git", ["show", "-s", "--format=%P", oid], { cwd });
+    return parents.split(" ").filter(Boolean)[0] ?? null;
+  }
   async tree(cwd, oid) {
     const result = await runProcess("git", ["ls-tree", "-r", "-z", "--long", oid], { cwd });
     return parseLsTree(result.stdout);
@@ -20381,6 +20412,23 @@ var GitClient = class {
     );
     return parseNameStatus(result.stdout);
   }
+  async changedFilesWithCopies(cwd, oldOid, newOid) {
+    const result = await runProcess(
+      "git",
+      [
+        "diff",
+        "--name-status",
+        "-z",
+        "--find-renames",
+        "--find-copies",
+        "--find-copies-harder",
+        oldOid,
+        newOid
+      ],
+      { cwd }
+    );
+    return parseNameStatus(result.stdout);
+  }
   async readDocument(cwd, sourceOid, filePath) {
     assertGitPath(filePath);
     const result = await runProcess("git", ["ls-tree", "-z", "--long", sourceOid, "--", filePath], {
@@ -20643,6 +20691,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 +20715,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 +20724,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 = [
@@ -27969,11 +28092,22 @@ function selectedLineText(value, startLine, endLine) {
 function lines(text5) {
   return normalizeLf(text5).split("\n");
 }
+function countLineRangeOccurrences(documentLines, selected) {
+  let occurrences = 0;
+  for (let index2 = 0; index2 <= documentLines.length - selected.length; index2 += 1) {
+    if (selected.every((line, offset) => documentLines[index2 + offset] === line)) {
+      occurrences += 1;
+    }
+  }
+  return occurrences;
+}
 function mapUnchangedLineRange(sourceText, destinationText, startLine, endLine) {
   if (startLine < 1 || endLine < startLine) return null;
   const sourceLines = lines(sourceText);
   if (endLine > sourceLines.length) return null;
   if (sourceText === destinationText) return { startLine, endLine };
+  const selected = sourceLines.slice(startLine - 1, endLine);
+  if (countLineRangeOccurrences(sourceLines, selected) !== 1) return null;
   const mapping = /* @__PURE__ */ new Map();
   let sourceIndex = 1;
   let destinationIndex = 1;
@@ -27999,14 +28133,8 @@ function mapUnchangedLineRange(sourceText, destinationText, startLine, endLine)
   for (let line = startLine; line <= endLine; line += 1) {
     if (mapping.get(line) !== mappedStart + line - startLine) return null;
   }
-  const selected = sourceLines.slice(startLine - 1, endLine);
-  let occurrences = 0;
   const destinationLines = lines(destinationText);
-  for (let index2 = 0; index2 <= destinationLines.length - selected.length; index2 += 1) {
-    if (selected.every((line, offset) => destinationLines[index2 + offset] === line))
-      occurrences += 1;
-    if (occurrences > 1) return null;
-  }
+  if (countLineRangeOccurrences(destinationLines, selected) !== 1) return null;
   return { startLine: mappedStart, endLine: mappedEnd };
 }
 function findUniqueQuotedLineRange(quotedText, destinationText) {
@@ -28034,6 +28162,11 @@ function placeMutableDocumentComment(anchor, currentText) {
   return range ? { outdated: false, range } : { outdated: true, range: null };
 }
 
+// src/domain/walkthrough-reference.ts
+function walkthroughReferenceFingerprint(sourceOid, reference) {
+  return JSON.stringify([sourceOid, reference.path, reference.startLine, reference.endLine]);
+}
+
 // src/domain/source-excerpt.ts
 var SOURCE_EXCERPT_CONTEXT_LINES = 20;
 var MAX_SOURCE_EXCERPT_LINES = 200;
@@ -41003,7 +41136,8 @@ var codeReferenceIdPattern = /^[A-Za-z][A-Za-z0-9_-]{0,63}$/;
 var walkthroughDiagramNodePattern = /^[A-Za-z][A-Za-z0-9_-]{0,63}$/;
 var mermaidIdentifierPattern = /[A-Za-z][A-Za-z0-9_-]{0,63}/g;
 var mermaidEdgePattern = /[<|o*x]*[-.=~]{2,}[|o*x>]*/g;
-var mermaidKeywords = /* @__PURE__ */ new Set([
+var mermaidClassShorthandPattern = /:::[A-Za-z][A-Za-z0-9_-]*(?:,[A-Za-z][A-Za-z0-9_-]*)*/g;
+var flowchartAndClassKeywords = /* @__PURE__ */ new Set([
   "class",
   "classDef",
   "classDiagram",
@@ -41015,12 +41149,19 @@ var mermaidKeywords = /* @__PURE__ */ new Set([
   "style",
   "subgraph"
 ]);
-function mermaidIdentifiers(value) {
-  return [...value.matchAll(mermaidIdentifierPattern)].map(([identifier]) => identifier).filter((identifier) => !mermaidKeywords.has(identifier));
+var noMermaidKeywords = /* @__PURE__ */ new Set();
+function mermaidIdentifiers(value, excludedKeywords) {
+  return [...value.matchAll(mermaidIdentifierPattern)].map(([identifier]) => identifier).filter((identifier) => !excludedKeywords.has(identifier));
 }
-function mermaidLineWithoutLabels(value) {
+function mermaidLineWithoutComment(value) {
   const commentIndex = value.indexOf("%%");
-  const uncommented = commentIndex === -1 ? value : value.slice(0, commentIndex);
+  return commentIndex === -1 ? value : value.slice(0, commentIndex);
+}
+function mermaidLineWithoutClassShorthand(value) {
+  return value.replace(mermaidClassShorthandPattern, "");
+}
+function mermaidLineWithoutLabels(value) {
+  const uncommented = mermaidLineWithoutComment(value);
   const withoutQuotedLabels = uncommented.replace(/"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'/g, " ").replace(/\|[^|]*\|/g, " ").replace(/--\s+[^-\n]+\s+-->/g, " -->").replace(/-\.\s+[^.\n]+\s+\.->/g, " -.->").replace(/==\s+[^=\n]+\s+==>/g, " ==>");
   let result = "";
   const closingDelimiters = [];
@@ -41045,33 +41186,105 @@ function mermaidLineWithoutLabels(value) {
   }
   return result;
 }
-function addMermaidEdgeEndpoints(line, nodeIds) {
-  const edges = [...line.matchAll(mermaidEdgePattern)];
+function addMermaidEdgeEndpoints(line, nodeIds, excludedKeywords) {
+  const endpointLine = mermaidLineWithoutClassShorthand(line);
+  const edges = [...endpointLine.matchAll(mermaidEdgePattern)];
   for (let index2 = 0; index2 < edges.length; index2 += 1) {
     const edge = edges[index2];
     const edgeStart = edge.index;
     const edgeEnd = edgeStart + edge[0].length;
     const leftStart = index2 === 0 ? 0 : edges[index2 - 1].index + edges[index2 - 1][0].length;
-    const rightEnd = index2 + 1 === edges.length ? line.length : edges[index2 + 1].index;
-    const left = line.slice(leftStart, edgeStart);
-    const right = line.slice(edgeEnd, rightEnd);
-    const leftIdentifiers = mermaidIdentifiers(left);
-    const rightIdentifiers = mermaidIdentifiers(right);
+    const rightEnd = index2 + 1 === edges.length ? endpointLine.length : edges[index2 + 1].index;
+    const left = endpointLine.slice(leftStart, edgeStart);
+    const right = endpointLine.slice(edgeEnd, rightEnd);
+    const leftIdentifiers = mermaidIdentifiers(left, excludedKeywords);
+    const rightIdentifiers = mermaidIdentifiers(right, excludedKeywords);
     const leftEndpoints = left.includes("&") ? leftIdentifiers : leftIdentifiers.slice(-1);
     const rightEndpoints = right.includes("&") ? rightIdentifiers : rightIdentifiers.slice(0, 1);
     for (const identifier of [...leftEndpoints, ...rightEndpoints]) nodeIds.add(identifier);
   }
 }
+function addSequenceMessageParticipants(line, nodeIds) {
+  const message = line.match(
+    /^([A-Za-z][A-Za-z0-9_-]{0,63})\s*<*[-=]+[)>x]+\s*[+-]?([A-Za-z][A-Za-z0-9_-]{0,63})\b/
+  );
+  if (!message) return;
+  nodeIds.add(message[1]);
+  nodeIds.add(message[2]);
+}
+var erCardinalitySource = [
+  "one\\s+or\\s+zero",
+  "one\\s+or\\s+(?:more|many)",
+  "zero\\s+or\\s+(?:one|more|many)",
+  "only\\s+one",
+  "many\\([01]\\)",
+  "[01]\\+",
+  "many",
+  "one",
+  "\\d+(?:\\.\\d+)?"
+].join("|");
+var erTextualRelationshipPattern = new RegExp(
+  `^([A-Za-z][A-Za-z0-9_-]{0,63})\\s+(?:${erCardinalitySource})\\s+(?:to|optionally\\s+to)\\s+(?:${erCardinalitySource})\\s+([A-Za-z][A-Za-z0-9_-]{0,63})\\b`,
+  "i"
+);
+function addErRelationshipEntities(line, nodeIds) {
+  const relationship = line.match(
+    /^([A-Za-z][A-Za-z0-9_-]{0,63})\s+[|o}{]+[.-]{2}[|o}{]+\s+([A-Za-z][A-Za-z0-9_-]{0,63})\b/
+  ) ?? line.match(erTextualRelationshipPattern);
+  if (!relationship) return;
+  nodeIds.add(relationship[1]);
+  nodeIds.add(relationship[2]);
+}
 function addMermaidDiagramNodes(source, nodeIds) {
   const lines2 = source.split("\n");
   const header = lines2.map((line) => mermaidLineWithoutLabels(line).trim()).find((line) => line.length > 0);
-  const diagramType = header?.match(/^(flowchart|graph|classDiagram)\b/)?.[1];
+  const diagramType = header?.match(
+    /^(flowchart|graph|classDiagram|sequenceDiagram|stateDiagram-v2|erDiagram|architecture-beta)\b/
+  )?.[1];
   if (!diagramType) return;
   for (const rawLine of lines2) {
-    for (const statement of mermaidLineWithoutLabels(rawLine).split(";")) {
+    const diagramLine = diagramType === "erDiagram" || diagramType === "sequenceDiagram" ? mermaidLineWithoutComment(rawLine) : mermaidLineWithoutLabels(rawLine);
+    for (const statement of diagramLine.split(";")) {
       const line = statement.trim();
-      if (!line || /^(flowchart|graph|classDiagram)\b/.test(line)) continue;
-      addMermaidEdgeEndpoints(line, nodeIds);
+      if (!line || /^(flowchart|graph|classDiagram|sequenceDiagram|stateDiagram-v2|erDiagram|architecture-beta)\b/.test(
+        line
+      )) {
+        continue;
+      }
+      if (diagramType === "sequenceDiagram") {
+        const participant = line.match(
+          /^(?:participant|actor)\s+([A-Za-z][A-Za-z0-9_-]{0,63})(?:\s*@\s*\{|\s+as\b|\s*$)/
+        )?.[1];
+        if (participant) nodeIds.add(participant);
+        else addSequenceMessageParticipants(line, nodeIds);
+        continue;
+      }
+      if (diagramType === "architecture-beta") {
+        const service = line.match(/^service\s+([A-Za-z][A-Za-z0-9_-]{0,63})(?:\s|\(|$)/)?.[1];
+        if (service) nodeIds.add(service);
+        continue;
+      }
+      if (diagramType === "stateDiagram-v2") {
+        addMermaidEdgeEndpoints(line, nodeIds, noMermaidKeywords);
+        const alias = line.match(/^state\s+.+?\s+as\s+([A-Za-z][A-Za-z0-9_-]{0,63})\b/)?.[1];
+        const declaration = alias ? void 0 : line.match(/^state\s+([A-Za-z][A-Za-z0-9_-]{0,63})(?:\s|\{|$)/)?.[1];
+        const describedState = line.match(/^([A-Za-z][A-Za-z0-9_-]{0,63})\s*:/)?.[1];
+        const standaloneState = line.match(/^([A-Za-z][A-Za-z0-9_-]{0,63})$/)?.[1];
+        for (const identifier of [alias, declaration, describedState, standaloneState]) {
+          if (identifier) nodeIds.add(identifier);
+        }
+        continue;
+      }
+      if (diagramType === "erDiagram") {
+        const entityLine = mermaidLineWithoutClassShorthand(line);
+        addErRelationshipEntities(entityLine, nodeIds);
+        const entity = entityLine.match(
+          /^([A-Za-z][A-Za-z0-9_-]{0,63})(?:\s*\[[^\]\n]+\])?\s*(?:\{|$)/
+        )?.[1];
+        if (entity) nodeIds.add(entity);
+        continue;
+      }
+      addMermaidEdgeEndpoints(line, nodeIds, flowchartAndClassKeywords);
       if (diagramType === "classDiagram") {
         const declaration = line.match(/^class\s+([A-Za-z][A-Za-z0-9_-]{0,63})\b/)?.[1];
         const memberOwner = line.match(/^([A-Za-z][A-Za-z0-9_-]{0,63})\s*:/)?.[1];
@@ -41282,6 +41495,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);
@@ -41953,6 +42202,133 @@ var RvwService = class {
     }
     return walkthrough;
   }
+  async walkthroughReferenceFallbackTarget(pullRequest, sourceOid, filePath) {
+    const diffBaseOid = await this.git.firstParent(pullRequest.localRepositoryPath, sourceOid);
+    if (!diffBaseOid) {
+      return {
+        sourceOid,
+        path: filePath,
+        diffBaseOid: null,
+        oldPath: filePath,
+        newPath: filePath,
+        hasDiff: false
+      };
+    }
+    const change = (await this.git.changedFiles(pullRequest.localRepositoryPath, diffBaseOid, sourceOid)).find((candidate) => candidate.newPath === filePath);
+    return {
+      sourceOid,
+      path: filePath,
+      diffBaseOid,
+      oldPath: change?.oldPath ?? filePath,
+      newPath: change?.newPath ?? filePath,
+      hasDiff: change !== void 0
+    };
+  }
+  async resolveWalkthroughReference(pullRequestId, walkthroughId, referenceId) {
+    const pullRequest = this.getPullRequest(pullRequestId);
+    const walkthrough = this.getWalkthrough(pullRequestId, walkthroughId);
+    const reference = walkthrough.references.find((candidate) => candidate.id === referenceId);
+    if (!reference) {
+      throw new RvwError("NOT_FOUND", "Walkthrough\u306Ecode reference\u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093\u3002", {
+        status: 404
+      });
+    }
+    const referenceFingerprint = walkthroughReferenceFingerprint(walkthrough.sourceOid, reference);
+    const sourceDocument = await this.getDocument({
+      kind: "repository-file",
+      pullRequestId,
+      sourceOid: walkthrough.sourceOid,
+      path: reference.path
+    });
+    const latestHeadOid = pullRequest.latestHeadOid;
+    let latestPath = reference.path;
+    let latestDocument;
+    if (walkthrough.sourceOid === latestHeadOid) {
+      latestDocument = sourceDocument;
+    } else {
+      latestDocument = await this.getDocument({
+        kind: "repository-file",
+        pullRequestId,
+        sourceOid: latestHeadOid,
+        path: reference.path
+      });
+      if (latestDocument.availability === "missing") {
+        const successorPaths = [
+          ...new Set(
+            (await this.git.changedFilesWithCopies(
+              pullRequest.localRepositoryPath,
+              walkthrough.sourceOid,
+              latestHeadOid
+            )).filter(
+              (candidate) => (candidate.status.startsWith("R") || candidate.status.startsWith("C")) && candidate.oldPath === reference.path && candidate.newPath !== null
+            ).map((candidate) => candidate.newPath)
+          )
+        ];
+        latestPath = successorPaths.length === 1 ? successorPaths[0] : null;
+        latestDocument = latestPath === null ? null : await this.getDocument({
+          kind: "repository-file",
+          pullRequestId,
+          sourceOid: latestHeadOid,
+          path: latestPath
+        });
+      }
+    }
+    const latestFileExists = latestDocument !== null && latestDocument.availability !== "missing";
+    const latestFileDisplayable = latestDocument?.availability === "available";
+    const mappedRange = reference.startLine === null || reference.endLine === null ? latestFileDisplayable ? null : void 0 : sourceDocument.availability === "available" && latestDocument?.availability === "available" ? mapUnchangedLineRange(
+      sourceDocument.text ?? "",
+      latestDocument.text ?? "",
+      reference.startLine,
+      reference.endLine
+    ) : null;
+    const resolvedToLatest = latestFileDisplayable && (reference.startLine === null || reference.endLine === null || mappedRange !== null);
+    if (resolvedToLatest && latestPath !== null && latestDocument !== null) {
+      return {
+        outcome: "latest",
+        anchorSourceOid: walkthrough.sourceOid,
+        latestHeadOid,
+        referenceFingerprint,
+        target: {
+          sourceOid: latestHeadOid,
+          path: latestPath,
+          diffBaseOid: null,
+          oldPath: latestPath,
+          newPath: latestPath,
+          hasDiff: false,
+          startLine: mappedRange?.startLine ?? reference.startLine,
+          endLine: mappedRange?.endLine ?? reference.endLine
+        },
+        latestFile: null,
+        document: latestDocument
+      };
+    }
+    const targetFile = await this.walkthroughReferenceFallbackTarget(
+      pullRequest,
+      walkthrough.sourceOid,
+      reference.path
+    );
+    const latestFile = latestFileExists && latestPath !== null ? {
+      sourceOid: latestHeadOid,
+      path: latestPath,
+      diffBaseOid: null,
+      oldPath: latestPath,
+      newPath: latestPath,
+      hasDiff: false
+    } : null;
+    return {
+      outcome: "source-fallback",
+      anchorSourceOid: walkthrough.sourceOid,
+      latestHeadOid,
+      referenceFingerprint,
+      target: {
+        ...targetFile,
+        startLine: reference.startLine,
+        endLine: reference.endLine
+      },
+      latestFile,
+      document: sourceDocument
+    };
+  }
   getWalkthroughByUri(uri) {
     const walkthrough = this.database.getWalkthrough(parseWalkthroughUri(uri));
     if (!walkthrough) {
@@ -42001,7 +42377,7 @@ var RvwService = class {
       if (!markdown.mermaidNodeIds.has(nodeId)) {
         throw new RvwError(
           "INVALID_INPUT",
-          `Mermaid node\u304C\u672C\u6587\u306Eflowchart\u307E\u305F\u306FclassDiagram\u306B\u898B\u3064\u304B\u308A\u307E\u305B\u3093: ${nodeId}`
+          `Mermaid binding\u5BFE\u8C61\u304C\u672C\u6587\u306E\u5BFE\u5FDCdiagram\u306B\u898B\u3064\u304B\u308A\u307E\u305B\u3093: ${nodeId}`
         );
       }
     }
@@ -42639,6 +43015,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 +46911,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 +46943,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")) })
@@ -46691,6 +47078,17 @@ function createApp(service, options) {
       walkthroughs: service.listWalkthroughs(context.req.param("id"))
     })
   );
+  app.get(
+    "/api/pull-requests/:id/walkthroughs/:walkthroughId/references/:referenceId/resolve",
+    async (context) => context.json({
+      ok: true,
+      resolution: await service.resolveWalkthroughReference(
+        context.req.param("id"),
+        context.req.param("walkthroughId"),
+        context.req.param("referenceId")
+      )
+    })
+  );
   app.get(
     "/api/pull-requests/:id/walkthroughs/:walkthroughId",
     (context) => context.json({
@@ -46837,14 +47235,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 +47254,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 +47333,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 +47369,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 +47409,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 +47450,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 +47466,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 +47480,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 +47548,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 +47562,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 +47890,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 +48024,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 +48068,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 +48093,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 +48121,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 +48130,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 +48164,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 +48196,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 +48219,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 +48701,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 +48799,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 +48927,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 +48983,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 +49195,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 +49246,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 +49347,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 +49720,12 @@ if (bundledCli || process.argv[1] && import.meta.url === pathToFileURL(process.a
   await runCli();
 }
 export {
+  acquireRuntimeOrReuseExisting,
+  closeOwnedRuntime,
   completeBackgroundOpen,
   createProgram,
+  createRuntimeAgentSocketHandler,
+  holdRuntimeViewerLease,
   runCli,
   startBackgroundOpen,
   waitForServerShutdown