fleetlens 1.0.1 → 1.0.3

package/dist/daemon-worker.js

@@ -6860,11 +6860,204 @@ var init_file_probe = __esm({
   }
 });
 
-// src/daemon-worker.ts
+// src/pid.ts
+import { readFileSync as readFileSync21, writeFileSync as writeFileSync15, mkdirSync as mkdirSync14, unlinkSync as unlinkSync5 } from "node:fs";
+import { execFileSync as execFileSync3 } from "node:child_process";
+import { dirname as dirname13 } from "node:path";
+function writePid(filePath, pid, port, version) {
+  mkdirSync14(dirname13(filePath), { recursive: true });
+  let content = String(pid);
+  if (port != null) {
+    content += `:${port}`;
+    if (version) content += `:${version}`;
+  }
+  writeFileSync15(filePath, content, "utf8");
+}
+function readPid(filePath) {
+  try {
+    const content = readFileSync21(filePath, "utf8").trim();
+    const [pidStr, portStr, versionStr] = content.split(":");
+    const pid = parseInt(pidStr, 10);
+    if (Number.isNaN(pid)) return null;
+    const port = portStr ? parseInt(portStr, 10) : void 0;
+    return {
+      pid,
+      port: Number.isNaN(port) ? void 0 : port,
+      version: versionStr || void 0
+    };
+  } catch {
+    return null;
+  }
+}
+function isProcessAlive(pid, markers) {
+  try {
+    process.kill(pid, 0);
+  } catch {
+    return false;
+  }
+  if (!markers || markers.length === 0) return true;
+  try {
+    const cmd = execFileSync3("ps", ["-p", String(pid), "-o", "command="], {
+      encoding: "utf8"
+    }).trim();
+    return markers.some((m) => cmd.includes(m));
+  } catch {
+    return false;
+  }
+}
+function cleanStalePid(filePath, markers) {
+  const entry = readPid(filePath);
+  if (entry === null) return false;
+  if (isProcessAlive(entry.pid, markers)) return false;
+  try {
+    unlinkSync5(filePath);
+  } catch {
+  }
+  return true;
+}
+function removePid(filePath) {
+  try {
+    unlinkSync5(filePath);
+  } catch {
+  }
+}
+var init_pid = __esm({
+  "src/pid.ts"() {
+    "use strict";
+  }
+});
+
+// src/server.ts
 import { spawn as spawn3 } from "node:child_process";
-import { closeSync, existsSync as existsSync19, mkdirSync as mkdirSync14, openSync, readFileSync as readFileSync21, writeFileSync as writeFileSync15 } from "node:fs";
-import { dirname as dirname12, join as join13 } from "node:path";
+import { join as join14, dirname as dirname14 } from "node:path";
 import { fileURLToPath } from "node:url";
+import { existsSync as existsSync20, realpathSync as realpathSync3, readFileSync as readFileSync22 } from "node:fs";
+import { homedir as homedir7 } from "node:os";
+function appDir() {
+  const here = dirname14(fileURLToPath(import.meta.url));
+  return join14(here, "..", "app", "apps", "web");
+}
+function cliBinRealPath() {
+  const argv1 = process.argv[1] ?? "";
+  try {
+    return realpathSync3(argv1);
+  } catch {
+    return argv1;
+  }
+}
+function onDiskVersion() {
+  try {
+    const here = dirname14(fileURLToPath(import.meta.url));
+    const pkg = JSON.parse(readFileSync22(join14(here, "..", "package.json"), "utf8"));
+    return pkg.version ?? "1.0.3";
+  } catch {
+    return "1.0.3";
+  }
+}
+function getServerStatus() {
+  cleanStalePid(PID_FILE, SERVER_MARKERS);
+  const entry = readPid(PID_FILE);
+  if (entry !== null && isProcessAlive(entry.pid, SERVER_MARKERS)) {
+    return { running: true, pid: entry.pid, port: entry.port ?? DEFAULT_PORT, version: entry.version };
+  }
+  return { running: false };
+}
+async function startServer(opts = {}) {
+  const port = opts.port ?? (parseInt(process.env.CCLENS_PORT ?? "", 10) || DEFAULT_PORT);
+  const serverJs = join14(appDir(), "server.js");
+  if (!existsSync20(serverJs)) {
+    throw new Error(`Server not found at ${serverJs}. Reinstall with: npm install -g fleetlens`);
+  }
+  const portInUse = await checkPort(port);
+  if (portInUse) {
+    throw new Error(`Port ${port} is in use. Use --port to specify a different port.`);
+  }
+  const dataDir = join14(homedir7(), ".claude", "projects");
+  const child = spawn3(process.execPath, [serverJs], {
+    detached: true,
+    stdio: "ignore",
+    env: {
+      ...process.env,
+      PORT: String(port),
+      HOSTNAME: "localhost",
+      CCLENS_DATA_DIR: dataDir,
+      FLEETLENS_CLI_BIN: cliBinRealPath(),
+      FLEETLENS_WEB_START_DAEMON: opts.autoStartDaemon === false ? "0" : "1"
+    },
+    cwd: appDir()
+  });
+  child.unref();
+  const pid = child.pid;
+  writePid(PID_FILE, pid, port, onDiskVersion());
+  await waitForHealth(`http://localhost:${port}`, 3e4);
+  return { pid, port };
+}
+async function probeServerHealth(port, timeoutMs) {
+  try {
+    await fetch(`http://localhost:${port}/api/health`, {
+      signal: AbortSignal.timeout(timeoutMs)
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function restartWedgedServer(pid, port) {
+  try {
+    process.kill(pid, "SIGKILL");
+  } catch {
+  }
+  removePid(PID_FILE);
+  await waitForPortFree(port, 5e3);
+  return startServer({ port });
+}
+async function checkPort(port) {
+  const { createServer } = await import("node:net");
+  return new Promise((resolve4) => {
+    const server = createServer();
+    server.once("error", () => resolve4(true));
+    server.once("listening", () => {
+      server.close(() => resolve4(false));
+    });
+    server.listen(port, "localhost");
+  });
+}
+async function waitForPortFree(port, timeoutMs) {
+  const start = Date.now();
+  while (Date.now() - start < timeoutMs) {
+    if (!await checkPort(port)) return;
+    await new Promise((r) => setTimeout(r, 200));
+  }
+}
+async function waitForHealth(url, timeoutMs) {
+  const start = Date.now();
+  while (Date.now() - start < timeoutMs) {
+    try {
+      const res = await fetch(url);
+      if (res.ok) return;
+    } catch {
+    }
+    await new Promise((r) => setTimeout(r, 500));
+  }
+  throw new Error(`Server did not become healthy within ${timeoutMs / 1e3}s`);
+}
+var PID_FILE, DEFAULT_PORT, SERVER_MARKERS;
+var init_server = __esm({
+  "src/server.ts"() {
+    "use strict";
+    init_pid();
+    init_fs();
+    PID_FILE = cclensPath("pid");
+    DEFAULT_PORT = 3321;
+    SERVER_MARKERS = ["next-server", "server.js"];
+  }
+});
+
+// src/daemon-worker.ts
+import { spawn as spawn4 } from "node:child_process";
+import { closeSync, existsSync as existsSync21, mkdirSync as mkdirSync15, openSync, readFileSync as readFileSync23, writeFileSync as writeFileSync16 } from "node:fs";
+import { dirname as dirname15, join as join15 } from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // src/usage/token.ts
 import { execFileSync } from "node:child_process";
@@ -7192,8 +7385,8 @@ async function refreshAccessToken(entry) {
           break;
         }
       }
-      const { writeFileSync: writeFileSync16 } = await import("node:fs");
-      writeFileSync16(p, JSON.stringify(raw, null, 2), "utf8");
+      const { writeFileSync: writeFileSync17 } = await import("node:fs");
+      writeFileSync17(p, JSON.stringify(raw, null, 2), "utf8");
     } catch {
     }
     return j.access_token;
@@ -9111,7 +9304,7 @@ function buildIngestPayload(inputs) {
   return {
     ingestId: randomUUID(),
     observedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    cliVersion: "1.0.1",
+    cliVersion: "1.0.3",
     ...richRollup || inputs.enrichedExtras || inputs.artifactSignals ? { schemaVersion: RICH_ROLLUP_SCHEMA_VERSION } : {},
     ...inputs.rollup ? { dailyRollup: inputs.rollup } : {},
     ...richRollup ? { richRollup } : {},
@@ -14384,14 +14577,56 @@ var ENRICHMENT_SYSTEM_PROMPT = SYSTEM_PROMPT;
 // ../entries/dist/llm-runner.js
 init_fs();
 import { spawn as spawn2 } from "node:child_process";
-import { mkdirSync as mkdirSync11, appendFileSync as appendFileSync5, writeFileSync as writeFileSync12, existsSync as existsSync15 } from "node:fs";
-import { join as join12 } from "node:path";
+import { mkdirSync as mkdirSync11, appendFileSync as appendFileSync5, writeFileSync as writeFileSync12, existsSync as existsSync16 } from "node:fs";
+import { join as join13 } from "node:path";
 import { randomUUID as randomUUID4 } from "node:crypto";
 
-// ../entries/dist/tmux-runner.js
-import { mkdirSync as mkdirSync10, writeFileSync as writeFileSync11, existsSync as existsSync14, readdirSync as readdirSync5, realpathSync as realpathSync2, readFileSync as readFileSync17, unlinkSync as unlinkSync3, renameSync as renameSync5 } from "node:fs";
-import { join as join11 } from "node:path";
+// ../entries/dist/claude-bin.js
+import { existsSync as existsSync14 } from "node:fs";
+import { join as join11, dirname as dirname11, delimiter } from "node:path";
 import { homedir as homedir5 } from "node:os";
+function resolveClaudeBin(opts = {}) {
+  const env = opts.env ?? process.env;
+  const home = opts.home ?? homedir5();
+  const execPath = opts.execPath ?? process.execPath;
+  const exists = opts.exists ?? existsSync14;
+  for (const dir of (env.PATH ?? "").split(delimiter)) {
+    if (!dir)
+      continue;
+    const onPath = join11(dir, "claude");
+    if (exists(onPath))
+      return onPath;
+  }
+  return [
+    join11(home, ".local", "bin", "claude"),
+    // native installer
+    join11(home, ".claude", "local", "claude"),
+    // legacy local install
+    join11(dirname11(execPath), "claude"),
+    // npm -g, beside the node running us
+    "/opt/homebrew/bin/claude",
+    "/usr/local/bin/claude"
+  ].find(exists);
+}
+function claudeSpawnEnv(bin, env = process.env, execPath = process.execPath) {
+  const parts = (env.PATH ?? "").split(delimiter).filter(Boolean);
+  for (const dir of [dirname11(execPath), dirname11(bin)]) {
+    if (!parts.includes(dir))
+      parts.unshift(dir);
+  }
+  return { ...env, PATH: parts.join(delimiter) };
+}
+var ClaudeBinNotFoundError = class extends Error {
+  constructor() {
+    super("claude CLI not found. Looked on PATH and in ~/.local/bin, ~/.claude/local, the npm global bin, homebrew, and /usr/local/bin. Install it, or if Fleetlens was started at login, restart it from a terminal: fleetlens stop && fleetlens start");
+    this.name = "ClaudeBinNotFoundError";
+  }
+};
+
+// ../entries/dist/tmux-runner.js
+import { mkdirSync as mkdirSync10, writeFileSync as writeFileSync11, existsSync as existsSync15, readdirSync as readdirSync5, realpathSync as realpathSync2, readFileSync as readFileSync17, unlinkSync as unlinkSync3, renameSync as renameSync5 } from "node:fs";
+import { join as join12 } from "node:path";
+import { homedir as homedir6 } from "node:os";
 import { spawnSync } from "node:child_process";
 var TmuxUnavailableError = class extends Error {
   constructor(message) {
@@ -14414,18 +14649,18 @@ function which(bin) {
 function tmuxRunnerAvailable() {
   if (!which("tmux"))
     return { ok: false, reason: "tmux not on PATH" };
-  if (!which("claude"))
-    return { ok: false, reason: "claude not on PATH" };
+  if (!resolveClaudeBin())
+    return { ok: false, reason: "claude CLI not found" };
   return { ok: true };
 }
 function runtimeCwd() {
-  const dir = join11(homedir5(), ".cclens", "runtime");
-  if (!existsSync14(dir))
+  const dir = join12(homedir6(), ".cclens", "runtime");
+  if (!existsSync15(dir))
     mkdirSync10(dir, { recursive: true });
   return realpathSync2(dir);
 }
 function ensureRuntimeCwdTrusted(cwd) {
-  const cfgPath = join11(homedir5(), ".claude.json");
+  const cfgPath = join12(homedir6(), ".claude.json");
   let cfg;
   try {
     cfg = JSON.parse(readFileSync17(cfgPath, "utf8"));
@@ -14462,18 +14697,18 @@ async function runClaudeUnderTmuxImpl(args) {
   const tmuxBin = args.tmuxBin ?? which("tmux");
   if (!tmuxBin)
     throw new TmuxUnavailableError("tmux not on PATH");
-  const claudeBin = args.claudeBin ?? which("claude");
+  const claudeBin = args.claudeBin ?? resolveClaudeBin();
   if (!claudeBin)
-    throw new TmuxUnavailableError("claude not on PATH");
+    throw new TmuxUnavailableError("claude CLI not found");
   if (args.signal?.aborted)
     throw new TmuxRunError("aborted before spawn");
   const cwd = runtimeCwd();
   ensureRuntimeCwdTrusted(cwd);
   const runId = `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
   const sessionName = `cclens-${runId}`;
-  const systemFile = join11(cwd, `system-${runId}.txt`);
-  const userFile = join11(cwd, `user-${runId}.txt`);
-  const wrapper = join11(cwd, `run-${runId}.sh`);
+  const systemFile = join12(cwd, `system-${runId}.txt`);
+  const userFile = join12(cwd, `user-${runId}.txt`);
+  const wrapper = join12(cwd, `run-${runId}.sh`);
   writeFileSync11(systemFile, args.systemPrompt);
   writeFileSync11(userFile, args.reminder ? `${args.userPrompt}
 
@@ -14492,10 +14727,10 @@ exec ${shellEscape(claudeBin)} \\
   "$USR"
 `, { mode: 493 });
   const existingBefore = snapshotAllTranscripts();
-  const spawn4 = spawnSync(tmuxBin, ["new-session", "-d", "-s", sessionName, "-x", "140", "-y", "50", "-c", cwd, wrapper], { encoding: "utf8" });
-  if (spawn4.status !== 0) {
+  const spawn5 = spawnSync(tmuxBin, ["new-session", "-d", "-s", sessionName, "-x", "140", "-y", "50", "-c", cwd, wrapper], { encoding: "utf8" });
+  if (spawn5.status !== 0) {
     cleanup(cwd, runId, tmuxBin, sessionName);
-    throw new TmuxRunError(`tmux new-session failed: ${spawn4.stderr.trim()}`);
+    throw new TmuxRunError(`tmux new-session failed: ${spawn5.stderr.trim()}`);
   }
   const onAbort = () => {
     try {
@@ -14552,7 +14787,7 @@ function num(v) {
 function sleep(ms) {
   return new Promise((r) => setTimeout(r, ms));
 }
-var PROJECTS_ROOT = () => join11(homedir5(), ".claude", "projects");
+var PROJECTS_ROOT = () => join12(homedir6(), ".claude", "projects");
 function snapshotAllTranscripts() {
   const out = /* @__PURE__ */ new Set();
   const root = PROJECTS_ROOT();
@@ -14563,7 +14798,7 @@ function snapshotAllTranscripts() {
     return out;
   }
   for (const sub of subs) {
-    const dir = join11(root, sub);
+    const dir = join12(root, sub);
     let files;
     try {
       files = readdirSync5(dir);
@@ -14572,7 +14807,7 @@ function snapshotAllTranscripts() {
     }
     for (const f of files) {
       if (f.endsWith(".jsonl"))
-        out.add(join11(dir, f));
+        out.add(join12(dir, f));
     }
   }
   return out;
@@ -14613,7 +14848,7 @@ async function discoverTranscript(targetCwd, existingBefore, startMs, timeoutMs,
       subs = [];
     }
     for (const sub of subs) {
-      const dir = join11(root, sub);
+      const dir = join12(root, sub);
       let files;
       try {
         files = readdirSync5(dir);
@@ -14623,7 +14858,7 @@ async function discoverTranscript(targetCwd, existingBefore, startMs, timeoutMs,
       for (const f of files) {
         if (!f.endsWith(".jsonl"))
           continue;
-        const full = join11(dir, f);
+        const full = join12(dir, f);
         if (existingBefore.has(full))
           continue;
         if (readJsonlCwd(full) === targetCwd)
@@ -14697,7 +14932,7 @@ function cleanup(cwd, runId, tmuxBin, sessionName, transcriptPath) {
     }
     for (const f of [`system-${runId}.txt`, `user-${runId}.txt`, `run-${runId}.sh`]) {
       try {
-        unlinkSync3(join11(cwd, f));
+        unlinkSync3(join12(cwd, f));
       } catch {
       }
     }
@@ -14712,7 +14947,7 @@ function shellEscape(s) {
 // ../entries/dist/llm-runner.js
 var RUNS_DIR = cclensPath("llm-runs");
 function ensureRunsDir() {
-  if (!existsSync15(RUNS_DIR)) {
+  if (!existsSync16(RUNS_DIR)) {
     try {
       mkdirSync11(RUNS_DIR, { recursive: true });
     } catch {
@@ -14741,7 +14976,7 @@ function newRunId(kind) {
   return `${ts}_${kind}_${short}`;
 }
 function tracePath(runId) {
-  return join12(RUNS_DIR, `${runId}.jsonl`);
+  return join13(RUNS_DIR, `${runId}.jsonl`);
 }
 function safeAppend(path11, line) {
   try {
@@ -14884,7 +15119,14 @@ function runClaudePrintMode(args) {
       "--append-system-prompt",
       args.systemPrompt
     ];
-    const proc = spawn2("claude", claudeArgs, { stdio: ["pipe", "pipe", "pipe"], env: { ...process.env } });
+    const claudeBin = resolveClaudeBin();
+    if (!claudeBin) {
+      const err = new ClaudeBinNotFoundError();
+      safeAppend(trace, JSON.stringify({ _meta: { type: "spawn_error", run_id: runId, ts: (/* @__PURE__ */ new Date()).toISOString(), error: err.message } }) + "\n");
+      reject(err);
+      return;
+    }
+    const proc = spawn2(claudeBin, claudeArgs, { stdio: ["pipe", "pipe", "pipe"], env: claudeSpawnEnv(claudeBin) });
     safeAppend(trace, JSON.stringify({ _meta: { type: "spawned", run_id: runId, pid: proc.pid } }) + "\n");
     const stdinPayload = args.reminder ? `${args.userPrompt}
 
@@ -15140,8 +15382,8 @@ function applyEnrichmentError(entry, errorMessage, model, costUsd, generatedAt,
 
 // ../entries/dist/budget.js
 init_fs();
-import { appendFileSync as appendFileSync6, readFileSync as readFileSync18, existsSync as existsSync16, mkdirSync as mkdirSync12 } from "node:fs";
-import { dirname as dirname11 } from "node:path";
+import { appendFileSync as appendFileSync6, readFileSync as readFileSync18, existsSync as existsSync17, mkdirSync as mkdirSync12 } from "node:fs";
+import { dirname as dirname12 } from "node:path";
 var spendPathCached = null;
 function spendPath() {
   if (spendPathCached)
@@ -15151,12 +15393,12 @@ function spendPath() {
 }
 function appendSpend(record) {
   const p = spendPath();
-  mkdirSync12(dirname11(p), { recursive: true });
+  mkdirSync12(dirname12(p), { recursive: true });
   appendFileSync6(p, JSON.stringify(record) + "\n", { encoding: "utf8" });
 }
 function monthToDateSpend(now = /* @__PURE__ */ new Date()) {
   const p = spendPath();
-  if (!existsSync16(p))
+  if (!existsSync17(p))
     return 0;
   const year = now.getUTCFullYear();
   const month = now.getUTCMonth();
@@ -15183,7 +15425,7 @@ function monthToDateSpend(now = /* @__PURE__ */ new Date()) {
 
 // ../entries/dist/pipeline-lock.js
 init_fs();
-import { writeFileSync as writeFileSync13, unlinkSync as unlinkSync4, existsSync as existsSync17, readFileSync as readFileSync19, statSync as statSync7 } from "node:fs";
+import { writeFileSync as writeFileSync13, unlinkSync as unlinkSync4, existsSync as existsSync18, readFileSync as readFileSync19, statSync as statSync7 } from "node:fs";
 var STALE_MS2 = 60 * 1e3;
 var HEARTBEAT_MS = 30 * 1e3;
 var lockPathCached = null;
@@ -15229,7 +15471,7 @@ function pidAlive(pid) {
 }
 function interactiveLockFresh(nowMs) {
   const p = lockPath();
-  if (!existsSync17(p))
+  if (!existsSync18(p))
     return false;
   try {
     const mtime = statSync7(p).mtimeMs;
@@ -15250,7 +15492,7 @@ function interactiveLockFresh(nowMs) {
 var THIRTY_MIN_MS = 30 * 60 * 1e3;
 
 // ../entries/dist/settings.js
-import { readFileSync as readFileSync20, writeFileSync as writeFileSync14, renameSync as renameSync6, chmodSync as chmodSync2, mkdirSync as mkdirSync13, existsSync as existsSync18 } from "node:fs";
+import { readFileSync as readFileSync20, writeFileSync as writeFileSync14, renameSync as renameSync6, chmodSync as chmodSync2, mkdirSync as mkdirSync13, existsSync as existsSync19 } from "node:fs";
 init_fs();
 var DEFAULT_SETTINGS = {
   ai_features: {
@@ -15282,7 +15524,7 @@ function fromDisk(d) {
 }
 function readSettings() {
   const p = settingsPath();
-  if (!existsSync18(p))
+  if (!existsSync19(p))
     return DEFAULT_SETTINGS;
   try {
     const raw = readFileSync20(p, "utf8");
@@ -18045,30 +18287,73 @@ async function getUpdateAvailability() {
   if (isDevMode()) return null;
   const latest = await fetchLatestVersion();
   if (latest === null) return {
-    current: "1.0.1",
+    current: "1.0.3",
     latest: null,
     updateAvailable: false
   };
   return {
-    current: "1.0.1",
+    current: "1.0.3",
     latest,
-    updateAvailable: shouldUpdate("1.0.1", latest)
+    updateAvailable: shouldUpdate("1.0.3", latest)
   };
 }
 
+// src/daemon-worker.ts
+init_server();
+
+// src/watchdog.ts
+var FAILURE_THRESHOLD = 3;
+var MAX_RESTARTS_PER_WINDOW = 3;
+var WINDOW_MS = 60 * 60 * 1e3;
+var ServerWatchdog = class {
+  failures = 0;
+  restartsAt = [];
+  /** A different pid is serving now. The failure run belongs to the old
+   *  process — a fresh server gets full grace — but the restart cap stays:
+   *  watchdog restarts change the pid too, and clearing the cap on every
+   *  one would disarm the flap guard entirely. */
+  noteNewInstance() {
+    this.failures = 0;
+  }
+  /** No tracked server at all (pid file gone). Watchdog restarts never pass
+   *  through this state — only an operator stop (or a cycle the watchdog
+   *  happens to observe mid-gap) does — so a human is at the wheel and the
+   *  restart budget re-arms in full. */
+  noteServerGone() {
+    this.failures = 0;
+    this.restartsAt = [];
+  }
+  onProbe(ok, nowMs) {
+    if (ok) {
+      this.failures = 0;
+      return "ok";
+    }
+    this.failures = Math.min(this.failures + 1, FAILURE_THRESHOLD);
+    if (this.failures < FAILURE_THRESHOLD) return "failing";
+    this.restartsAt = this.restartsAt.filter((t) => nowMs - t < WINDOW_MS);
+    if (this.restartsAt.length >= MAX_RESTARTS_PER_WINDOW) return "gave-up";
+    this.restartsAt.push(nowMs);
+    this.failures = 0;
+    return "restart";
+  }
+};
+
 // src/daemon-worker.ts
 var USAGE_LOG3 = cclensPath("usage.jsonl");
 var DAEMON_LOG = cclensPath("daemon.log");
 var UPDATE_STATE = cclensPath("daemon-update.json");
 var WATCHDOG_INTERVAL_MS = 5 * 1e3;
 var AUTO_UPDATE_INTERVAL_MS = 6 * 60 * 60 * 1e3;
-mkdirSync14(dirname12(USAGE_LOG3), { recursive: true });
+var SERVER_HEALTH_INTERVAL_MS = 60 * 1e3;
+var SERVER_HEALTH_TIMEOUT_MS = 10 * 1e3;
+mkdirSync15(dirname15(USAGE_LOG3), { recursive: true });
 function log2(level, message) {
   appendDaemonLogLine(level, message);
 }
 var nextPollAtMs = 0;
 var nextAuxPollAtMs = 0;
 var nextTeamSyncAtMs = 0;
+var nextServerHealthAtMs = 0;
 var firstTeamSync = true;
 var currentIntervalMs = BASE_INTERVAL_MS;
 var waitingForRefresh = false;
@@ -18101,14 +18386,14 @@ var perceptionHandle = setInterval(async () => {
 }, PERCEPTION_INTERVAL_MS);
 function readUpdateState() {
   try {
-    return JSON.parse(readFileSync21(UPDATE_STATE, "utf8"));
+    return JSON.parse(readFileSync23(UPDATE_STATE, "utf8"));
   } catch {
     return null;
   }
 }
 function writeUpdateState(state) {
   try {
-    writeFileSync15(UPDATE_STATE, JSON.stringify(state, null, 2), { mode: 384 });
+    writeFileSync16(UPDATE_STATE, JSON.stringify(state, null, 2), { mode: 384 });
   } catch {
   }
 }
@@ -18121,7 +18406,7 @@ function nextUpdateCheckFromState(nowMs) {
 }
 var nextUpdateCheckAtMs = nextUpdateCheckFromState(Date.now());
 function cliEntryPath() {
-  return join13(dirname12(fileURLToPath(import.meta.url)), "index.js");
+  return join15(dirname15(fileURLToPath2(import.meta.url)), "index.js");
 }
 async function runDaemonUpdateCheck() {
   if (process.env.FLEETLENS_DAEMON_AUTO_UPDATE === "0") {
@@ -18153,7 +18438,7 @@ async function runDaemonUpdateCheck() {
       return;
     }
     const entry = cliEntryPath();
-    if (!existsSync19(entry)) {
+    if (!existsSync21(entry)) {
       log2("warn", `update check found ${availability.latest}, but CLI entry is missing at ${entry}`);
       return;
     }
@@ -18162,7 +18447,7 @@ async function runDaemonUpdateCheck() {
       logFd = openSync(DAEMON_LOG, "a");
     } catch {
     }
-    const child = spawn3(process.execPath, [entry, "update"], {
+    const child = spawn4(process.execPath, [entry, "update"], {
       detached: true,
       stdio: ["ignore", logFd, logFd],
       env: { ...process.env, FLEETLENS_UPDATE_SOURCE: "daemon" }
@@ -18192,6 +18477,44 @@ async function runDaemonUpdateCheck() {
     nextUpdateCheckAtMs = Date.now() + AUTO_UPDATE_INTERVAL_MS;
   }
 }
+var serverWatchdog = new ServerWatchdog();
+var lastServerVerdict = "ok";
+var lastServerPid = null;
+async function runServerHealthCheck() {
+  const status = getServerStatus();
+  if (!status.running) {
+    if (lastServerPid !== null) {
+      serverWatchdog.noteServerGone();
+      lastServerPid = null;
+    }
+    return;
+  }
+  if (status.pid !== lastServerPid) {
+    serverWatchdog.noteNewInstance();
+    lastServerPid = status.pid;
+  }
+  const ok = await probeServerHealth(status.port, SERVER_HEALTH_TIMEOUT_MS);
+  const verdict = serverWatchdog.onProbe(ok, Date.now());
+  if (verdict === "failing") {
+    log2("warn", `[watchdog] server pid=${status.pid} not answering on port ${status.port}`);
+  } else if (verdict === "restart") {
+    log2("warn", `[watchdog] server pid=${status.pid} wedged; force-restarting on port ${status.port}`);
+    try {
+      const fresh = await restartWedgedServer(status.pid, status.port);
+      log2("info", `[watchdog] server restarted (pid=${fresh.pid}, port=${fresh.port})`);
+    } catch (err) {
+      log2("error", `[watchdog] restart failed: ${err.message}`);
+    }
+  } else if (verdict === "gave-up" && lastServerVerdict !== "gave-up") {
+    log2(
+      "error",
+      `[watchdog] server keeps wedging after 3 restarts within the hour; standing down \u2014 run 'fleetlens start' to restart manually`
+    );
+  } else if (verdict === "ok" && lastServerVerdict !== "ok") {
+    log2("info", `[watchdog] server responding again (pid=${status.pid})`);
+  }
+  lastServerVerdict = verdict;
+}
 async function pollAuxiliaryUsage() {
   for (const source of agentSources) {
     if (source.kind === "claude-code") continue;
@@ -18353,6 +18676,10 @@ async function runLoop() {
     if (Date.now() >= nextUpdateCheckAtMs) {
       await runDaemonUpdateCheck();
     }
+    if (Date.now() >= nextServerHealthAtMs) {
+      await runServerHealthCheck();
+      nextServerHealthAtMs = Date.now() + SERVER_HEALTH_INTERVAL_MS;
+    }
     await sleep2(WATCHDOG_INTERVAL_MS);
   }
 }