getgloss 0.8.3 → 0.8.5

package/dist/cli/index.js

@@ -1,6 +1,10 @@
 #!/usr/bin/env node
 
 // src/cli/index.ts
+import { randomUUID as randomUUID3 } from "crypto";
+import { constants } from "fs";
+import { access, rm as rm5, writeFile as writeFile4 } from "fs/promises";
+import path7 from "path";
 import { Command } from "commander";
 import openBrowser from "open";
 
@@ -14,6 +18,9 @@ function formatError(error) {
 function isFileNotFound(error) {
   return error instanceof Error && "code" in error && error.code === "ENOENT";
 }
+function isPermissionError(error) {
+  return error instanceof Error && "code" in error && (error.code === "EACCES" || error.code === "EPERM");
+}
 
 // src/shared/paths.ts
 import { mkdir } from "fs/promises";
@@ -23,7 +30,7 @@ import path from "path";
 // package.json
 var package_default = {
   name: "getgloss",
-  version: "0.8.3",
+  version: "0.8.5",
   description: "Local browser-based diff review for coding-agent loops.",
   type: "module",
   packageManager: "pnpm@10.33.2",
@@ -119,6 +126,9 @@ function globalStateDir() {
 function globalServerFile() {
   return path.join(globalStateDir(), "server.json");
 }
+function globalServerLockDir() {
+  return path.join(globalStateDir(), "server.lock");
+}
 function globalLogDir() {
   return path.join(globalStateDir(), "logs");
 }
@@ -198,10 +208,10 @@ function parseJsonValue(value, guard, label) {
   return value;
 }
 function isServerInfo(value) {
-  return isRecord(value) && isNumber(value.pid) && isNumber(value.port) && isString(value.version) && isString(value.startedAt) && isString(value.stateDir);
+  return isRecord(value) && isNumber(value.pid) && isNumber(value.port) && isString(value.version) && isString(value.startedAt) && isString(value.stateDir) && isOptionalString(value.cwd) && isOptionalString(value.daemonPath);
 }
 function isHealthResponse(value) {
-  return isRecord(value) && isBoolean(value.ok) && isString(value.version) && isNumber(value.activeReviews);
+  return isRecord(value) && isBoolean(value.ok) && isString(value.version) && isNumber(value.activeReviews) && isOptionalNumber(value.connections) && isOptionalString(value.stateDir) && isOptionalString(value.cwd) && isOptionalString(value.daemonPath);
 }
 function isClearReviewsResult(value) {
   return isRecord(value) && isString(value.reviewsDir) && isString(value.cutoff) && isNumber(value.olderThanDays) && isBoolean(value.dryRun) && isArrayOf(value.candidates, isClearReviewEntry) && isArrayOf(value.deleted, isClearReviewEntry) && isArrayOf(value.skipped, isClearReviewSkipped) && isRecord(value.counts) && isNumber(value.counts.candidates) && isNumber(value.counts.deleted) && isNumber(value.counts.skipped);
@@ -592,11 +602,127 @@ function cleanupResult({
   };
 }
 
+// src/shared/server-info.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import { readFile as readFile2, rm as rm3, writeFile as writeFile2 } from "fs/promises";
+import path3 from "path";
+
+// src/shared/json.ts
+import { randomUUID } from "crypto";
+import { rename, rm as rm2, writeFile } from "fs/promises";
+import path2 from "path";
+function serializeJson(value) {
+  return `${JSON.stringify(value, null, 2)}
+`;
+}
+async function writeJsonFile(filePath, value) {
+  await writeTextFile(filePath, serializeJson(value));
+}
+async function writeTextFile(filePath, value) {
+  const tempPath = path2.join(
+    path2.dirname(filePath),
+    `.${path2.basename(filePath)}.${process.pid}.${randomUUID()}.tmp`
+  );
+  try {
+    await writeFile(tempPath, value);
+    await rename(tempPath, filePath);
+  } catch (error) {
+    await rm2(tempPath, { force: true }).catch(() => void 0);
+    throw error;
+  }
+}
+
+// src/shared/server-info.ts
+async function readServerInfo() {
+  let raw;
+  try {
+    raw = await readFile2(globalServerFile(), "utf8");
+  } catch (error) {
+    if (isFileNotFound(error)) {
+      return null;
+    }
+    if (isPermissionError(error)) {
+      throw new Error(serverInfoPermissionMessage("read", error), { cause: error });
+    }
+    throw new Error(`Could not read server info at ${globalServerFile()}: ${formatError(error)}`, {
+      cause: error
+    });
+  }
+  try {
+    return parseJson(raw, isServerInfo, "server info");
+  } catch (error) {
+    throw new Error(`Invalid server info at ${globalServerFile()}: ${formatError(error)}`, {
+      cause: error
+    });
+  }
+}
+async function writeServerInfo(info) {
+  try {
+    await ensureDir(globalStateDir());
+  } catch (error) {
+    if (isPermissionError(error)) {
+      throw new Error(serverInfoPermissionMessage("create", error), { cause: error });
+    }
+    throw error;
+  }
+  try {
+    await writeJsonFile(globalServerFile(), info);
+  } catch (error) {
+    if (!isPermissionError(error)) {
+      throw error;
+    }
+    await assertStateDirWritable();
+    try {
+      await writeFile2(globalServerFile(), serializeServerInfo(info));
+    } catch (directWriteError) {
+      throw new Error(serverInfoPermissionMessage("write", directWriteError), {
+        cause: directWriteError
+      });
+    }
+  }
+}
+async function removeServerInfoFile() {
+  try {
+    await rm3(globalServerFile(), { force: true });
+    return null;
+  } catch (error) {
+    return serverInfoPermissionMessage("remove", error);
+  }
+}
+function serverInfoPermissionMessage(action, error) {
+  const stateDir = globalStateDir();
+  const source = process.env.GLOSS_STATE_DIR ? `GLOSS_STATE_DIR=${stateDir}` : "GLOSS_STATE_DIR is not set; defaulting to ~/.gloss";
+  return [
+    `Could not ${action} Gloss server state at ${globalServerFile()}: ${formatError(error)}.`,
+    "`server.json` is not a review lock, so there is nothing to unlock after a review.",
+    `Check that ${stateDir} and ${globalServerFile()} are owned and writable by your user.`,
+    `On macOS, if the file is immutable, run \`chflags nouchg "${globalServerFile()}"\`.`,
+    `For sandboxed agents, set GLOSS_STATE_DIR to a writable directory. ${source}.`
+  ].join(" ");
+}
+function serializeServerInfo(info) {
+  return `${JSON.stringify(info, null, 2)}
+`;
+}
+async function assertStateDirWritable() {
+  const probePath = path3.join(
+    globalStateDir(),
+    `.server.json.${process.pid}.${randomUUID2()}.probe`
+  );
+  try {
+    await writeFile2(probePath, "");
+    await rm3(probePath, { force: true });
+  } catch (error) {
+    await rm3(probePath, { force: true }).catch(() => void 0);
+    throw new Error(serverInfoPermissionMessage("write", error), { cause: error });
+  }
+}
+
 // src/cli/git.ts
 import { execa } from "execa";
 
 // src/shared/language.ts
-import path2 from "path";
+import path4 from "path";
 var languageByExtension = {
   cjs: "js",
   css: "css",
@@ -618,7 +744,7 @@ var languageByExtension = {
   yml: "yaml"
 };
 function languageForPath(filePath) {
-  const ext = path2.extname(filePath).slice(1).toLowerCase();
+  const ext = path4.extname(filePath).slice(1).toLowerCase();
   if (!ext) {
     return null;
   }
@@ -984,67 +1110,15 @@ async function assertGitAvailable() {
 // src/cli/lifecycle.ts
 import { execFile, spawn } from "child_process";
 import { closeSync, existsSync, openSync } from "fs";
-import { rm as rm3 } from "fs/promises";
+import { mkdir as mkdir2, readFile as readFile3, rm as rm4, stat, writeFile as writeFile3 } from "fs/promises";
 import { userInfo } from "os";
+import path5 from "path";
 import { fileURLToPath } from "url";
 import { promisify } from "util";
 import getPort from "get-port";
 
-// src/shared/server-info.ts
-import { readFile as readFile2 } from "fs/promises";
-
-// src/shared/json.ts
-import { randomUUID } from "crypto";
-import { rename, rm as rm2, writeFile } from "fs/promises";
-import path3 from "path";
-function serializeJson(value) {
-  return `${JSON.stringify(value, null, 2)}
-`;
-}
-async function writeJsonFile(filePath, value) {
-  await writeTextFile(filePath, serializeJson(value));
-}
-async function writeTextFile(filePath, value) {
-  const tempPath = path3.join(
-    path3.dirname(filePath),
-    `.${path3.basename(filePath)}.${process.pid}.${randomUUID()}.tmp`
-  );
-  try {
-    await writeFile(tempPath, value);
-    await rename(tempPath, filePath);
-  } catch (error) {
-    await rm2(tempPath, { force: true }).catch(() => void 0);
-    throw error;
-  }
-}
-
-// src/shared/server-info.ts
-async function readServerInfo() {
-  let raw;
-  try {
-    raw = await readFile2(globalServerFile(), "utf8");
-  } catch (error) {
-    if (isFileNotFound(error)) {
-      return null;
-    }
-    throw new Error(`Could not read server info at ${globalServerFile()}: ${formatError(error)}`, {
-      cause: error
-    });
-  }
-  try {
-    return parseJson(raw, isServerInfo, "server info");
-  } catch (error) {
-    throw new Error(`Invalid server info at ${globalServerFile()}: ${formatError(error)}`, {
-      cause: error
-    });
-  }
-}
-async function writeServerInfo(info) {
-  await ensureDir(globalStateDir());
-  await writeJsonFile(globalServerFile(), info);
-}
-
 // src/cli/server-client.ts
+var timedWatchAttemptMs = 1e3;
 var ServerClient = class {
   constructor(baseUrl) {
     this.baseUrl = baseUrl;
@@ -1123,11 +1197,15 @@ var ServerClient = class {
         throw new Error(`watch timed out after ${timeoutSeconds} seconds`);
       }
       const controller = new AbortController();
-      const timeout = remainingMs ? setTimeout(() => controller.abort(), remainingMs) : null;
+      const timeoutMs = remainingMs === null ? null : Math.min(remainingMs, timedWatchAttemptMs);
+      const timeout = timeoutMs ? setTimeout(() => controller.abort(), timeoutMs) : null;
       try {
         return await this.readReviewEvents(reviewId, controller.signal);
       } catch (error) {
         if (isAbortError(error)) {
+          if (deadline && Date.now() < deadline) {
+            throw new Error("watch stream ended before completion");
+          }
           throw new Error(`watch timed out after ${timeoutSeconds} seconds`);
         }
         if (!isPrematureWatchEnd(error)) {
@@ -1172,20 +1250,20 @@ var ServerClient = class {
       }
     }
   }
-  async get(path5, guard, label) {
-    const response = await fetch(`${this.baseUrl}${path5}`);
+  async get(path8, guard, label) {
+    const response = await fetch(`${this.baseUrl}${path8}`);
     return parseResponse(response, guard, label);
   }
-  async post(path5, body, guard, label) {
-    const response = await fetch(`${this.baseUrl}${path5}`, {
+  async post(path8, body, guard, label) {
+    const response = await fetch(`${this.baseUrl}${path8}`, {
       method: "POST",
       headers: { "content-type": "application/json" },
       body: JSON.stringify(body)
     });
     return parseResponse(response, guard, label);
   }
-  async delete(path5, guard, label) {
-    const response = await fetch(`${this.baseUrl}${path5}`, { method: "DELETE" });
+  async delete(path8, guard, label) {
+    const response = await fetch(`${this.baseUrl}${path8}`, { method: "DELETE" });
     return parseResponse(response, guard, label);
   }
 };
@@ -1210,6 +1288,8 @@ async function sleep(milliseconds) {
 var execFileAsync = promisify(execFile);
 var gracefulShutdownTimeoutMs = 2e3;
 var forceShutdownTimeoutMs = 1e3;
+var serverLockTimeoutMs = 8e3;
+var staleServerLockMs = 3e4;
 function serverUrl(info) {
   return `http://localhost:${info.port}`;
 }
@@ -1225,17 +1305,26 @@ async function isServerResponsive(info) {
   }
 }
 async function ensureServer(options = {}) {
-  const existing = await readServerInfo();
-  if (existing && await isServerResponsive(existing)) {
-    return existing;
-  }
-  return startServer(options);
+  return withServerLock(async () => {
+    const existing = await readServerInfo();
+    await reapStaleDaemons(existing);
+    if (existing && await isServerResponsive(existing)) {
+      return existing;
+    }
+    return startServerUnlocked(existing, options);
+  });
 }
 async function startServer(options = {}) {
-  const existing = await readServerInfo();
-  if (existing && await isServerResponsive(existing)) {
-    return existing;
-  }
+  return withServerLock(async () => {
+    const existing = await readServerInfo();
+    await reapStaleDaemons(existing);
+    if (existing && await isServerResponsive(existing)) {
+      return existing;
+    }
+    return startServerUnlocked(existing, options);
+  });
+}
+async function startServerUnlocked(existing, options = {}) {
   if (existing) {
     await retireServer(existing);
   }
@@ -1274,9 +1363,16 @@ async function launchServer(port) {
     port,
     version: packageVersion,
     startedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    stateDir: globalStateDir()
+    stateDir: globalStateDir(),
+    cwd: process.cwd(),
+    daemonPath
   };
-  await writeServerInfo(info);
+  try {
+    await writeServerInfo(info);
+  } catch (error) {
+    await terminatePid(info.pid);
+    throw error;
+  }
   const deadline = Date.now() + 8e3;
   while (Date.now() < deadline) {
     if (await isServerResponsive(info)) {
@@ -1288,36 +1384,135 @@ async function launchServer(port) {
   await removeServerInfoForPid(info.pid);
   throw new Error(`Server did not become responsive. See ${globalServerLogFile()}`);
 }
+async function withServerLock(fn) {
+  const release = await acquireServerLock();
+  try {
+    return await fn();
+  } finally {
+    await release();
+  }
+}
+async function acquireServerLock() {
+  await ensureDir(globalStateDir());
+  const lockDir = globalServerLockDir();
+  const ownerFile = serverLockOwnerFile();
+  const deadline = Date.now() + serverLockTimeoutMs;
+  while (true) {
+    try {
+      await mkdir2(lockDir);
+      try {
+        await writeFile3(
+          ownerFile,
+          `${JSON.stringify({ pid: process.pid, startedAt: (/* @__PURE__ */ new Date()).toISOString() }, null, 2)}
+`
+        );
+      } catch (error) {
+        await rm4(lockDir, { recursive: true, force: true }).catch(() => void 0);
+        throw error;
+      }
+      return () => rm4(lockDir, { recursive: true, force: true });
+    } catch (error) {
+      if (!isAlreadyExistsError(error)) {
+        throw error;
+      }
+      if (await removeStaleServerLock(lockDir, ownerFile)) {
+        continue;
+      }
+      if (Date.now() >= deadline) {
+        throw new Error(`Timed out waiting for Gloss server lock at ${lockDir}`);
+      }
+      await sleep2(50);
+    }
+  }
+}
+async function removeStaleServerLock(lockDir, ownerFile) {
+  const owner = await readServerLockOwner(ownerFile);
+  if (owner?.pid && !isPidAlive(owner.pid)) {
+    await rm4(lockDir, { recursive: true, force: true });
+    return true;
+  }
+  if (!owner && await isOldLockDir(lockDir)) {
+    await rm4(lockDir, { recursive: true, force: true });
+    return true;
+  }
+  return false;
+}
+async function readServerLockOwner(ownerFile) {
+  try {
+    const raw = await readFile3(ownerFile, "utf8");
+    const parsed = JSON.parse(raw);
+    return typeof parsed.pid === "number" && Number.isFinite(parsed.pid) ? { pid: parsed.pid } : null;
+  } catch {
+    return null;
+  }
+}
+async function isOldLockDir(lockDir) {
+  try {
+    const info = await stat(lockDir);
+    return Date.now() - info.mtimeMs > staleServerLockMs;
+  } catch {
+    return false;
+  }
+}
+function serverLockOwnerFile() {
+  return path5.join(globalServerLockDir(), "owner.json");
+}
+function isAlreadyExistsError(error) {
+  return error instanceof Error && "code" in error && error.code === "EEXIST";
+}
 async function stopServer(options = {}) {
   if (options.all) {
-    const info2 = await readServerInfo();
-    const daemonPids = await listGlossDaemonPids();
+    const { info: info2, warning: readWarning2 } = await readServerInfoForStop();
+    const daemonPids = (await listGlossDaemonProcesses()).map((processInfo) => processInfo.pid);
     const stoppedPids = [];
     for (const pid of daemonPids) {
       if (await terminatePid(pid)) {
         stoppedPids.push(pid);
       }
     }
-    await rm3(globalServerFile(), { force: true });
-    return { stopped: stoppedPids.length > 0, info: info2, stoppedPids };
+    return withWarning(
+      { stopped: stoppedPids.length > 0, info: info2, stoppedPids },
+      combineWarnings(readWarning2, await removeServerInfoFile())
+    );
   }
-  const info = await readServerInfo();
+  const { info, warning: readWarning } = await readServerInfoForStop();
   if (!info) {
-    return { stopped: false, info: null };
+    return withWarning({ stopped: false, info: null }, readWarning);
   }
   if (!isPidAlive(info.pid)) {
-    await removeServerInfoForPid(info.pid);
-    return { stopped: false, info };
+    return withWarning({ stopped: false, info }, await removeServerInfoForPid(info.pid));
   }
   if (!await isGlossDaemonPid(info.pid)) {
-    await removeServerInfoForPid(info.pid);
-    return { stopped: false, info };
+    return withWarning({ stopped: false, info }, await removeServerInfoForPid(info.pid));
   }
   const stopped = await terminatePid(info.pid);
+  let warning = null;
   if (stopped) {
-    await removeServerInfoForPid(info.pid);
+    warning = await removeServerInfoForPid(info.pid);
+  }
+  return withWarning({ stopped, info }, warning);
+}
+async function reapStaleDaemons(managed) {
+  if (process.env.GLOSS_SKIP_STALE_DAEMON_REAP === "1") {
+    return [];
+  }
+  const processes = await listGlossDaemonProcesses();
+  const managedProcess = managed ? processes.find((processInfo) => processInfo.pid === managed.pid) : null;
+  const managedSource = managedProcess ? daemonSourceKey(managedProcess) : managed?.daemonPath ? daemonPathSourceKey(managed.daemonPath) : null;
+  const reapedPids = [];
+  for (const processInfo of processes) {
+    const shouldReap = isMissingDaemonSource(processInfo) || isStaleHomebrewDaemon(processInfo) || managedSource !== null && processInfo.pid !== managed?.pid && daemonSourceKey(processInfo) === managedSource;
+    if (!shouldReap) {
+      continue;
+    }
+    if (await terminatePid(processInfo.pid)) {
+      reapedPids.push(processInfo.pid);
+      if (processInfo.pid === managed?.pid) {
+        await removeServerInfoForPid(processInfo.pid);
+      }
+    }
   }
-  return { stopped, info };
+  return reapedPids;
 }
 function isPidAlive(pid) {
   if (pid <= 0) {
@@ -1361,19 +1556,34 @@ async function waitForPidExit(pid, timeoutMs) {
     if (!isPidAlive(pid)) {
       return true;
     }
-    await new Promise((resolve) => setTimeout(resolve, 50));
+    await sleep2(50);
   }
   return !isPidAlive(pid);
 }
 async function removeServerInfoForPid(pid) {
   const current = await readServerInfo().catch(() => null);
   if (!current || current.pid === pid) {
-    await rm3(globalServerFile(), { force: true });
+    return removeServerInfoFile();
   }
+  return null;
+}
+function withWarning(result, warning) {
+  return warning ? { ...result, warning } : result;
+}
+async function readServerInfoForStop() {
+  try {
+    return { info: await readServerInfo(), warning: null };
+  } catch (error) {
+    return { info: null, warning: error instanceof Error ? error.message : String(error) };
+  }
+}
+function combineWarnings(...warnings) {
+  const present = warnings.filter((warning) => Boolean(warning));
+  return present.length > 0 ? present.join(" ") : null;
 }
 async function isGlossDaemonPid(pid) {
   const command = await readProcessCommand(pid);
-  return command ? isGlossDaemonCommand(command) : false;
+  return command ? parseGlossDaemonCommand(command) !== null : false;
 }
 async function readProcessCommand(pid) {
   try {
@@ -1384,6 +1594,9 @@ async function readProcessCommand(pid) {
   }
 }
 async function listGlossDaemonPids() {
+  return (await listGlossDaemonProcesses()).map((processInfo) => processInfo.pid);
+}
+async function listGlossDaemonProcesses() {
   let stdout;
   try {
     ({ stdout } = await execFileAsync("ps", ["-axo", "pid=,user=,command=", "-ww"]));
@@ -1391,25 +1604,60 @@ async function listGlossDaemonPids() {
     return [];
   }
   const currentUser = userInfo().username;
-  return parseGlossDaemonPids(stdout, currentUser, process.pid);
+  return parseGlossDaemonProcesses(stdout, currentUser, process.pid);
 }
-function parseGlossDaemonPids(stdout, currentUser, currentPid = process.pid) {
+function parseGlossDaemonProcesses(stdout, currentUser, currentPid = process.pid) {
   return stdout.split("\n").map((line) => /^\s*(\d+)\s+(\S+)\s+(.+)$/.exec(line)).filter((match) => Boolean(match)).map((match) => ({
     pid: Number(match[1]),
     user: match[2],
     command: match[3]
+  })).map((processInfo) => ({
+    ...processInfo,
+    parsed: parseGlossDaemonCommand(processInfo.command)
   })).filter(
-    ({ pid, user, command }) => pid !== currentPid && user === currentUser && isGlossDaemonCommand(command)
-  ).map(({ pid }) => pid);
+    (processInfo) => processInfo.pid !== currentPid && processInfo.user === currentUser && processInfo.parsed !== null
+  ).map(({ pid, user, command, parsed }) => ({
+    pid,
+    user,
+    command,
+    daemonPath: parsed.daemonPath,
+    ...parsed.homebrewVersion ? { homebrewVersion: parsed.homebrewVersion } : {}
+  }));
+}
+function parseGlossDaemonCommand(command) {
+  const match = /(?:^|\s)(?:\S*\/)?node\s+(\S*dist\/server\/daemon\.js)(?:\s|$)/.exec(command);
+  if (!match) {
+    return null;
+  }
+  const daemonPath = match[1];
+  const homebrewVersion = /\/Cellar\/gloss\/([^/]+)\/libexec\/lib\/node_modules\/getgloss\/dist\/server\/daemon\.js$/.exec(
+    daemonPath
+  )?.[1];
+  return {
+    daemonPath,
+    ...homebrewVersion ? { homebrewVersion } : {}
+  };
+}
+function isMissingDaemonSource(processInfo) {
+  return !existsSync(processInfo.daemonPath);
 }
-function isGlossDaemonCommand(command) {
-  return /(?:^|\s)(?:\S*\/)?node\s+\S*dist\/server\/daemon\.js(?:\s|$)/.test(command);
+function isStaleHomebrewDaemon(processInfo) {
+  return Boolean(processInfo.homebrewVersion && processInfo.homebrewVersion !== packageVersion);
+}
+function daemonSourceKey(processInfo) {
+  return daemonPathSourceKey(processInfo.daemonPath);
+}
+function daemonPathSourceKey(daemonPath) {
+  return path5.normalize(daemonPath);
+}
+async function sleep2(milliseconds) {
+  await new Promise((resolve) => setTimeout(resolve, milliseconds));
 }
 
 // src/server/store.ts
 import { createHash } from "crypto";
-import { readdir as readdir2, readFile as readFile3 } from "fs/promises";
-import path4 from "path";
+import { readdir as readdir2, readFile as readFile4 } from "fs/promises";
+import path6 from "path";
 import { ulid } from "ulid";
 
 // src/shared/comments.ts
@@ -1880,16 +2128,25 @@ var ReviewStore = class {
     const reviewLoads = [];
     for (const entry of entries) {
       if (entry.isDirectory()) {
-        reviewLoads.push(this.loadReview(entry.name));
+        reviewLoads.push(this.loadReviewForList(entry.name));
       }
     }
     await Promise.all(reviewLoads);
   }
+  async loadReviewForList(id) {
+    try {
+      return await this.loadReview(id);
+    } catch (error) {
+      process.stderr.write(`Warning: Skipping corrupt review ${id}: ${formatError(error)}
+`);
+      return null;
+    }
+  }
   async loadReview(id) {
     const metaPath = globalReviewMetaFile(id);
     let metaRaw;
     try {
-      metaRaw = await readFile3(metaPath, "utf8");
+      metaRaw = await readFile4(metaPath, "utf8");
     } catch (error) {
       if (isFileNotFound(error)) {
         return this.loadReviewFromTurnsOnly(id);
@@ -1971,8 +2228,8 @@ var ReviewStore = class {
     let diffRaw;
     try {
       [metaRaw, diffRaw] = await Promise.all([
-        readFile3(metaPath, "utf8"),
-        readFile3(diffPath, "utf8")
+        readFile4(metaPath, "utf8"),
+        readFile4(diffPath, "utf8")
       ]);
     } catch (error) {
       if (isFileNotFound(error)) {
@@ -2002,7 +2259,7 @@ var ReviewStore = class {
     const diffPath = globalReviewDiffFile(id);
     let diffRaw;
     try {
-      diffRaw = await readFile3(diffPath, "utf8");
+      diffRaw = await readFile4(diffPath, "utf8");
     } catch (error) {
       if (isFileNotFound(error)) {
         return null;
@@ -2182,9 +2439,9 @@ function reconcileTurn(meta, diff, feedback, resolution) {
     status,
     submittedAt: feedback?.timestamp ?? meta.submittedAt,
     resolvedAt: status === "resolved" ? resolution?.resolvedAt ?? meta.resolvedAt : void 0,
-    feedbackPath: feedback ? meta.feedbackPath ?? path4.join(meta.artifactDir, "feedback.json") : void 0,
-    markdownPath: feedback ? meta.markdownPath ?? path4.join(meta.artifactDir, "feedback.md") : void 0,
-    resolvedPath: resolution ? meta.resolvedPath ?? path4.join(meta.artifactDir, "resolved.json") : void 0,
+    feedbackPath: feedback ? meta.feedbackPath ?? path6.join(meta.artifactDir, "feedback.json") : void 0,
+    markdownPath: feedback ? meta.markdownPath ?? path6.join(meta.artifactDir, "feedback.md") : void 0,
+    resolvedPath: resolution ? meta.resolvedPath ?? path6.join(meta.artifactDir, "resolved.json") : void 0,
     diff,
     ...feedback ? { feedback } : {},
     ...resolution ? { resolution } : {}
@@ -2217,7 +2474,7 @@ function requiredPath(value, label) {
 async function readOptionalJsonFile(filePath, guard, label) {
   let raw;
   try {
-    raw = await readFile3(filePath, "utf8");
+    raw = await readFile4(filePath, "utf8");
   } catch (error) {
     if (isFileNotFound(error)) {
       return void 0;
@@ -2367,7 +2624,9 @@ program.command("start").description("Start or reuse the background server").opt
 });
 program.command("status").description("Show server and active reviews").action(async () => {
   const globals = program.opts();
-  const info = await readServerInfo();
+  let info = await readServerInfo();
+  await reapStaleDaemons(info);
+  info = await readServerInfo();
   const responsive = info ? await isServerResponsive(info) : false;
   const reviews = await listReviewsForStatus({ responsive, server: info });
   const status = { running: responsive, server: info, reviews };
@@ -2378,9 +2637,7 @@ program.command("status").description("Show server and active reviews").action(a
 program.command("stop").description("Stop the managed background server").option("--all", "stop all Gloss daemon processes for the current user").action(async (options) => {
   const globals = program.opts();
   const result = await stopServer({ all: options.all });
-  globals.json ? printJson(result) : printPlain(
-    options.all && result.stoppedPids ? `Stopped ${result.stoppedPids.length} Gloss daemon(s)` : result.stopped ? "Gloss server stopped" : "Gloss server was not running"
-  );
+  globals.json ? printJson(result) : printPlain(formatStopResult(result, options.all === true));
 });
 program.command("clear").description("Delete old completed review artifacts").option(
   "--older-than <days>",
@@ -2438,11 +2695,19 @@ program.command("doctor").description("Diagnose setup and validate git/state").a
       detail: error instanceof Error ? error.message : String(error)
     });
   }
-  const info = await readServerInfo();
+  checks.push(await checkStateDirAccess());
+  checks.push(await checkServerInfoAccess());
+  let info = null;
+  let serverStateError = null;
+  try {
+    info = await readServerInfo();
+  } catch (error) {
+    serverStateError = error;
+  }
   checks.push({
     name: "server",
     ok: info ? await isServerResponsive(info) : false,
-    detail: info ? serverUrl(info) : "not started"
+    detail: info ? serverUrl(info) : serverStateError ? formatError(serverStateError) : "not started"
   });
   try {
     const daemonPids = await listGlossDaemonPids();
@@ -2487,7 +2752,7 @@ async function watchReviewWithReconnect(reviewId, initialInfo, timeoutSeconds, o
       if (!isReconnectableWatchError(error)) {
         throw error;
       }
-      await sleep2(500);
+      await sleep3(500);
       const nextInfo = await ensureServer();
       if (nextInfo.port !== info.port) {
         await onServerChanged(nextInfo);
@@ -2496,6 +2761,46 @@ async function watchReviewWithReconnect(reviewId, initialInfo, timeoutSeconds, o
     }
   }
 }
+function formatStopResult(result, all) {
+  const status = all && result.stoppedPids ? `Stopped ${result.stoppedPids.length} Gloss daemon(s)` : result.stopped ? "Gloss server stopped" : "Gloss server was not running";
+  return result.warning ? `${status}
+Warning: ${result.warning}` : status;
+}
+async function checkStateDirAccess() {
+  const probePath = path7.join(globalStateDir(), `.doctor-${process.pid}-${randomUUID3()}.tmp`);
+  try {
+    await ensureDir(globalStateDir());
+    await access(globalStateDir(), constants.R_OK | constants.W_OK | constants.X_OK);
+    await writeFile4(probePath, "");
+    await rm5(probePath, { force: true });
+    return { name: "state-dir", ok: true, detail: stateDirDetail() };
+  } catch (error) {
+    await rm5(probePath, { force: true }).catch(() => void 0);
+    return {
+      name: "state-dir",
+      ok: false,
+      detail: `${stateDirDetail()}: ${formatError(error)}. Set GLOSS_STATE_DIR to a writable directory for sandboxed agents.`
+    };
+  }
+}
+async function checkServerInfoAccess() {
+  try {
+    await access(globalServerFile(), constants.R_OK | constants.W_OK);
+    return { name: "server-json", ok: true, detail: globalServerFile() };
+  } catch (error) {
+    if (isFileNotFound(error)) {
+      return { name: "server-json", ok: true, detail: "not present" };
+    }
+    return {
+      name: "server-json",
+      ok: false,
+      detail: serverInfoPermissionMessage("access", error)
+    };
+  }
+}
+function stateDirDetail() {
+  return process.env.GLOSS_STATE_DIR ? `${globalStateDir()} (from GLOSS_STATE_DIR)` : `${globalStateDir()} (default; set GLOSS_STATE_DIR for a writable sandbox state dir)`;
+}
 async function baseForExistingReview(client, reviewId) {
   const record = await client.getReview(reviewId);
   return record.diff.scope.mode === "explicit" ? record.diff.scope.requestedBase ?? record.diff.base.ref : null;
@@ -2526,7 +2831,7 @@ function isWatchTimeout(error) {
 function isReconnectableWatchError(error) {
   return error instanceof Error && !/^watch failed: [45]\d\d /.test(error.message);
 }
-async function sleep2(milliseconds) {
+async function sleep3(milliseconds) {
   await new Promise((resolve) => setTimeout(resolve, milliseconds));
 }
 program.parseAsync(process.argv).catch((error) => {