agent-remnote 1.5.0 → 1.5.1

package/dist/main.js

@@ -92343,29 +92343,235 @@ var WsClientLive = succeed10(WsClient, {
   })
 });
 
-// src/lib/managedRuntimePaths.ts
-import path19 from "node:path";
-function resolveManagedStateFile(params3) {
-  const defaultPath = resolveUserFilePath(params3.defaultStateFilePath);
-  const explicitPath = params3.explicitStateFilePath ? resolveUserFilePath(params3.explicitStateFilePath) : undefined;
-  const candidatePath = params3.candidate ? resolveUserFilePath(params3.candidate) : undefined;
-  if (!candidatePath) {
-    return explicitPath ?? defaultPath;
+// src/lib/apiUrls.ts
+function normalizeApiBasePath2(basePath) {
+  const trimmed2 = basePath.trim();
+  if (!trimmed2)
+    return "/v1";
+  const normalized = trimmed2.startsWith("/") ? trimmed2 : `/${trimmed2}`;
+  const withoutTrailing = normalized.replace(/\/+$/, "");
+  return withoutTrailing && withoutTrailing !== "/" ? withoutTrailing : "/";
+}
+function normalizeBaseUrl(baseUrl) {
+  return baseUrl.trim().replace(/\/+$/, "");
+}
+function resolveBasePrefix(baseUrl, fallbackBasePath) {
+  const parsed = new URL(normalizeBaseUrl(baseUrl));
+  const pathname = normalizeApiBasePath2(parsed.pathname);
+  if (pathname && pathname !== "/")
+    return normalizeApiBasePath2(pathname);
+  return normalizeApiBasePath2(fallbackBasePath);
+}
+function normalizeRoutePath(routePath) {
+  const trimmed2 = routePath.trim();
+  if (!trimmed2)
+    return "";
+  return `/${trimmed2.replace(/^\/+/, "")}`;
+}
+function buildApiBaseUrl(baseUrl, fallbackBasePath = "/v1") {
+  const parsed = new URL(normalizeBaseUrl(baseUrl));
+  const prefix2 = resolveBasePrefix(baseUrl, fallbackBasePath);
+  return prefix2 === "/" ? parsed.origin : `${parsed.origin}${prefix2}`;
+}
+function apiLocalBaseUrl(port3, basePath = "/v1") {
+  return buildApiBaseUrl(`http://127.0.0.1:${port3}`, basePath);
+}
+function apiContainerBaseUrl(port3, basePath = "/v1") {
+  return buildApiBaseUrl(`http://host.docker.internal:${port3}`, basePath);
+}
+function joinApiUrl(baseUrl, routePath, fallbackBasePath = "/v1") {
+  return `${buildApiBaseUrl(baseUrl, fallbackBasePath)}${normalizeRoutePath(routePath)}`;
+}
+
+// src/services/HostApiClient.ts
+function normalizeBaseUrl2(baseUrl) {
+  return baseUrl.trim().replace(/\/+$/, "");
+}
+function apiTimeoutError(params3) {
+  return new CliError({
+    code: "API_TIMEOUT",
+    message: `API timeout after ${params3.timeoutMs}ms`,
+    exitCode: 1,
+    details: { base_url: params3.baseUrl, path: params3.path, timeout_ms: params3.timeoutMs }
+  });
+}
+function apiUnavailableError(params3) {
+  return new CliError({
+    code: "API_UNAVAILABLE",
+    message: String(params3.error?.message || params3.error || "API request failed"),
+    exitCode: 1,
+    details: { base_url: params3.baseUrl, path: params3.path }
+  });
+}
+function exitCodeFromRemoteCode(code2) {
+  return code2 === "INVALID_ARGS" || code2 === "INVALID_PAYLOAD" || code2 === "PAYLOAD_TOO_LARGE" ? 2 : 1;
+}
+function parseEnvelope(raw4) {
+  if (!raw4 || typeof raw4 !== "object") {
+    return { ok: false, error: { code: "INTERNAL", message: "Invalid API response envelope" } };
   }
-  if (candidatePath === defaultPath)
-    return candidatePath;
-  if (explicitPath && candidatePath === explicitPath)
-    return candidatePath;
-  const pidRoot = path19.dirname(params3.pidFilePath);
-  const rel = path19.relative(pidRoot, candidatePath);
-  if (rel === "" || !rel.startsWith("..") && !path19.isAbsolute(rel)) {
-    return candidatePath;
+  return raw4;
+}
+function buildQuery(params3) {
+  const sp = new URLSearchParams;
+  for (const [key, value8] of Object.entries(params3)) {
+    if (value8 === undefined || value8 === null)
+      continue;
+    if (typeof value8 === "string") {
+      if (!value8.trim())
+        continue;
+      sp.set(key, value8);
+      continue;
+    }
+    if (typeof value8 === "number" || typeof value8 === "boolean") {
+      sp.set(key, String(value8));
+    }
   }
-  return explicitPath ?? defaultPath;
+  const query = sp.toString();
+  return query ? `?${query}` : "";
+}
+function requestJson(params3) {
+  const timeoutMs = Math.max(1, params3.timeoutMs ?? 15000);
+  const baseUrl = normalizeBaseUrl2(params3.baseUrl);
+  const url2 = joinApiUrl(baseUrl, params3.path, params3.basePath);
+  return async((resume2) => {
+    const controller = new AbortController;
+    const timer2 = setTimeout(() => controller.abort(), timeoutMs);
+    fetch(url2, {
+      method: params3.method,
+      headers: params3.method === "POST" ? { "content-type": "application/json" } : undefined,
+      body: params3.body === undefined ? undefined : JSON.stringify(params3.body),
+      signal: controller.signal
+    }).then(async (response) => {
+      clearTimeout(timer2);
+      let parsed;
+      try {
+        parsed = parseEnvelope(await response.json());
+      } catch (error4) {
+        resume2(fail8(new CliError({
+          code: "API_UNAVAILABLE",
+          message: "API returned a non-JSON response",
+          exitCode: 1,
+          details: { url: url2, status: response.status, error: String(error4?.message || error4) }
+        })));
+        return;
+      }
+      if (parsed.ok === true) {
+        resume2(succeed8(parsed.data));
+        return;
+      }
+      const code2 = typeof parsed.error?.code === "string" ? parsed.error.code : "INTERNAL";
+      const message2 = typeof parsed.error?.message === "string" ? parsed.error.message : "API request failed";
+      const hint = Array.isArray(parsed.hint) ? parsed.hint.map(String) : undefined;
+      resume2(fail8(new CliError({
+        code: code2,
+        message: message2,
+        exitCode: exitCodeFromRemoteCode(code2),
+        details: parsed.error?.details,
+        hint
+      })));
+    }).catch((error4) => {
+      clearTimeout(timer2);
+      if (error4?.name === "AbortError") {
+        resume2(fail8(apiTimeoutError({ baseUrl, path: params3.path, timeoutMs })));
+        return;
+      }
+      resume2(fail8(apiUnavailableError({ baseUrl, path: params3.path, error: error4 })));
+    });
+    return sync3(() => {
+      clearTimeout(timer2);
+      controller.abort();
+    });
+  });
 }
 
+class HostApiClient extends Tag2("HostApiClient")() {
+}
+var HostApiClientLive = effect(HostApiClient, gen2(function* () {
+  const cfg = yield* AppConfig;
+  const basePath = cfg.apiBasePath ?? "/v1";
+  const request = (params3) => requestJson({ ...params3, basePath });
+  return {
+    resolveRefValue: ({ baseUrl, body, timeoutMs }) => request({ baseUrl, path: "/ref/resolve", method: "POST", body, timeoutMs }),
+    resolvePlacement: ({ baseUrl, body, timeoutMs }) => request({ baseUrl, path: "/placement/resolve", method: "POST", body, timeoutMs }),
+    resolveStableSiblingRange: ({ baseUrl, body, timeoutMs }) => request({ baseUrl, path: "/selection/stable-sibling-range", method: "POST", body, timeoutMs }),
+    health: ({ baseUrl, timeoutMs }) => request({ baseUrl, path: "/health", method: "GET", timeoutMs }),
+    status: ({ baseUrl, timeoutMs }) => request({ baseUrl, path: "/status", method: "GET", timeoutMs }),
+    uiContextSnapshot: ({ baseUrl, stateFile, staleMs, timeoutMs }) => request({
+      baseUrl,
+      path: `/plugin/ui-context/snapshot${buildQuery({ stateFile, staleMs })}`,
+      method: "GET",
+      timeoutMs
+    }),
+    uiContextPage: ({ baseUrl, stateFile, staleMs, timeoutMs }) => request({
+      baseUrl,
+      path: `/plugin/ui-context/page${buildQuery({ stateFile, staleMs })}`,
+      method: "GET",
+      timeoutMs
+    }),
+    uiContextFocusedRem: ({ baseUrl, stateFile, staleMs, timeoutMs }) => request({
+      baseUrl,
+      path: `/plugin/ui-context/focused-rem${buildQuery({ stateFile, staleMs })}`,
+      method: "GET",
+      timeoutMs
+    }),
+    uiContextDescribe: ({ baseUrl, stateFile, staleMs, selectionLimit, timeoutMs }) => request({
+      baseUrl,
+      path: `/plugin/ui-context/describe${buildQuery({ stateFile, staleMs, selectionLimit })}`,
+      method: "GET",
+      timeoutMs
+    }),
+    selectionSnapshot: ({ baseUrl, stateFile, staleMs, timeoutMs }) => request({
+      baseUrl,
+      path: `/plugin/selection/snapshot${buildQuery({ stateFile, staleMs })}`,
+      method: "GET",
+      timeoutMs
+    }),
+    selectionRoots: ({ baseUrl, stateFile, staleMs, timeoutMs }) => request({
+      baseUrl,
+      path: `/plugin/selection/roots${buildQuery({ stateFile, staleMs })}`,
+      method: "GET",
+      timeoutMs
+    }),
+    selectionCurrent: ({ baseUrl, stateFile, staleMs, timeoutMs }) => request({
+      baseUrl,
+      path: `/plugin/selection/current${buildQuery({ stateFile, staleMs })}`,
+      method: "GET",
+      timeoutMs
+    }),
+    pluginCurrent: ({ baseUrl, stateFile, staleMs, selectionLimit, timeoutMs }) => request({
+      baseUrl,
+      path: `/plugin/current${buildQuery({ stateFile, staleMs, selectionLimit })}`,
+      method: "GET",
+      timeoutMs
+    }),
+    selectionOutline: ({ baseUrl, body, timeoutMs }) => request({ baseUrl, path: "/plugin/selection/outline", method: "POST", body, timeoutMs }),
+    uiContext: ({ baseUrl, timeoutMs }) => request({ baseUrl, path: "/ui-context", method: "GET", timeoutMs }),
+    selection: ({ baseUrl, timeoutMs }) => request({ baseUrl, path: "/selection", method: "GET", timeoutMs }),
+    searchDb: ({ baseUrl, ...body }) => request({ baseUrl, path: "/search/db", method: "POST", body }),
+    searchPlugin: ({ baseUrl, ...body }) => request({ baseUrl, path: "/search/plugin", method: "POST", body }),
+    writeApply: ({ baseUrl, body, timeoutMs }) => request({ baseUrl, path: "/write/apply", method: "POST", body, timeoutMs }),
+    readOutline: ({ baseUrl, body, timeoutMs }) => request({ baseUrl, path: "/read/outline", method: "POST", body, timeoutMs }),
+    readPageId: ({ baseUrl, body, timeoutMs }) => request({ baseUrl, path: "/read/page-id", method: "POST", body, timeoutMs }),
+    resolveRef: ({ baseUrl, body, timeoutMs }) => request({ baseUrl, path: "/read/resolve-ref", method: "POST", body, timeoutMs }),
+    byReference: ({ baseUrl, body, timeoutMs }) => request({ baseUrl, path: "/read/by-reference", method: "POST", body, timeoutMs }),
+    references: ({ baseUrl, body, timeoutMs }) => request({ baseUrl, path: "/read/references", method: "POST", body, timeoutMs }),
+    resolveQueryPowerup: ({ baseUrl, powerup, timeoutMs }) => request({ baseUrl, path: "/internal/query/resolve-powerup", method: "POST", body: { powerup }, timeoutMs }),
+    query: ({ baseUrl, body, timeoutMs }) => request({ baseUrl, path: "/read/query", method: "POST", body, timeoutMs }),
+    dailyRemId: ({ baseUrl, date: date6, offsetDays, timeoutMs }) => request({
+      baseUrl,
+      path: `/daily/rem-id${buildQuery({ date: date6, offsetDays })}`,
+      method: "GET",
+      timeoutMs
+    }),
+    queueWait: ({ baseUrl, txnId, timeoutMs, pollMs }) => request({ baseUrl, path: "/queue/wait", method: "POST", body: { txnId, timeoutMs, pollMs } }),
+    queueTxn: ({ baseUrl, txnId, timeoutMs }) => request({ baseUrl, path: `/queue/txns/${encodeURIComponent(txnId)}`, method: "GET", timeoutMs }),
+    triggerSync: ({ baseUrl, timeoutMs }) => request({ baseUrl, path: "/actions/trigger-sync", method: "POST", timeoutMs })
+  };
+}));
+
 // src/lib/pidTrust.ts
-import path20 from "node:path";
+import path19 from "node:path";
 function normalizeToken(value8) {
   return value8.trim().replace(/\\/g, "/").toLowerCase();
 }
@@ -92376,7 +92582,7 @@ function collectCommandTokens(raw4) {
     if (!normalized)
       continue;
     const unquoted = normalized.replace(/^['"]|['"]$/g, "");
-    const base = path20.basename(unquoted);
+    const base = path19.basename(unquoted);
     if (unquoted.includes("agent-remnote") || base.includes("agent-remnote")) {
       out.add("agent-remnote");
     }
@@ -92434,32 +92640,870 @@ function requireTrustedPidRecord(params3) {
   });
 }
 
-// src/lib/statuslineArtifacts.ts
-import { promises as fs15 } from "node:fs";
-
-// src/services/StatusLineFile.ts
-import { promises as fs14 } from "node:fs";
-import path21 from "node:path";
-class StatusLineFile extends Tag2("StatusLineFile")() {
-}
-function defaultTextFile() {
-  return path21.join(homeDir(), ".agent-remnote", "status-line.txt");
-}
-function defaultJsonFile() {
-  return path21.join(homeDir(), ".agent-remnote", "status-line.json");
-}
-function ensureDir8(p3) {
-  return fs14.mkdir(path21.dirname(p3), { recursive: true }).then(() => {
-    return;
-  });
-}
-async function readFileOrEmpty(filePath) {
+// src/lib/runtimeBuildInfo.ts
+import { createHash as createHash3 } from "node:crypto";
+import { existsSync as existsSync2, readFileSync as readFileSync2, readdirSync, statSync } from "node:fs";
+import path20 from "node:path";
+import { fileURLToPath as fileURLToPath3 } from "node:url";
+function packageInfo() {
   try {
-    return await fs14.readFile(filePath, "utf8");
-  } catch (e) {
-    if (e?.code === "ENOENT")
-      return "";
-    throw e;
+    const raw4 = readFileSync2(new URL("../../package.json", import.meta.url), "utf8");
+    const parsed = JSON.parse(raw4);
+    const name = typeof parsed?.name === "string" && parsed.name.trim() ? parsed.name.trim() : "agent-remnote";
+    const version = typeof parsed?.version === "string" && parsed.version.trim() ? parsed.version.trim() : "0.0.0";
+    return { name, version };
+  } catch {
+    return { name: "agent-remnote", version: "0.0.0" };
+  }
+}
+function fileMtimeMs(targetPath) {
+  try {
+    return Math.floor(statSync(targetPath).mtimeMs);
+  } catch {
+    return 0;
+  }
+}
+function latestMtimeMs(dirPath) {
+  if (!existsSync2(dirPath))
+    return 0;
+  let max7 = 0;
+  const stack = [dirPath];
+  while (stack.length > 0) {
+    const current2 = stack.pop();
+    let entries2 = [];
+    try {
+      entries2 = readdirSync(current2);
+    } catch {
+      continue;
+    }
+    for (const entry of entries2) {
+      const full = path20.join(current2, entry);
+      let st;
+      try {
+        st = statSync(full);
+      } catch {
+        continue;
+      }
+      if (st.isDirectory()) {
+        stack.push(full);
+      } else if (st.isFile()) {
+        max7 = Math.max(max7, Math.floor(st.mtimeMs));
+      }
+    }
+  }
+  return max7;
+}
+function detectMode() {
+  const url2 = import.meta.url;
+  if (url2.includes("/src/"))
+    return "src";
+  if (url2.includes("/dist/"))
+    return "dist";
+  return "unknown";
+}
+function computeDefaultBuildInfo() {
+  const pkg = packageInfo();
+  const mode = detectMode();
+  const srcDir = new URL("../", import.meta.url);
+  const packageJson = new URL("../../package.json", import.meta.url);
+  const sourceStamp = Math.max(latestMtimeMs(fileURLToPath3(srcDir)), fileMtimeMs(fileURLToPath3(packageJson)));
+  const buildIdInput = `${pkg.name}
+${pkg.version}
+${mode}
+${sourceStamp}`;
+  const buildId = createHash3("sha256").update(buildIdInput).digest("hex").slice(0, 12);
+  return {
+    name: pkg.name,
+    version: pkg.version,
+    build_id: `${pkg.version}:${buildId}`,
+    built_at: sourceStamp || Date.now(),
+    source_stamp: sourceStamp || Date.now(),
+    mode
+  };
+}
+var cached4;
+function parseEnvNumber(raw4, fallback) {
+  const parsed = Number(raw4);
+  return Number.isFinite(parsed) ? parsed : fallback;
+}
+function currentRuntimeBuildInfo() {
+  if (cached4)
+    return cached4;
+  const defaultInfo = computeDefaultBuildInfo();
+  cached4 = {
+    name: process.env.AGENT_REMNOTE_NAME?.trim() || defaultInfo.name,
+    version: process.env.AGENT_REMNOTE_VERSION?.trim() || defaultInfo.version,
+    build_id: process.env.AGENT_REMNOTE_BUILD_ID?.trim() || defaultInfo.build_id,
+    built_at: parseEnvNumber(process.env.AGENT_REMNOTE_BUILD_AT, defaultInfo.built_at),
+    source_stamp: parseEnvNumber(process.env.AGENT_REMNOTE_SOURCE_STAMP, defaultInfo.source_stamp),
+    mode: process.env.AGENT_REMNOTE_BUILD_MODE === "src" || process.env.AGENT_REMNOTE_BUILD_MODE === "dist" || process.env.AGENT_REMNOTE_BUILD_MODE === "unknown" ? process.env.AGENT_REMNOTE_BUILD_MODE : defaultInfo.mode
+  };
+  return cached4;
+}
+function runtimeVersionWarnings(params3) {
+  const warnings = [];
+  const compare2 = (label, other) => {
+    if (!other)
+      return;
+    if (other.build_id !== params3.current.build_id) {
+      warnings.push(`${label} build mismatch: current=${params3.current.build_id} live=${other.build_id}`);
+    }
+  };
+  compare2("daemon", params3.daemon);
+  compare2("plugin", params3.plugin);
+  compare2("api", params3.api);
+  return warnings;
+}
+
+// src/commands/api/_shared.ts
+var API_HEALTH_TIMEOUT_MS = 2000;
+var API_START_WAIT_DEFAULT_MS = 15000;
+var API_STOP_WAIT_DEFAULT_MS = 5000;
+function childCommandLine(params3) {
+  const command = process.argv[0];
+  const script = process.argv[1];
+  if (!command || !script) {
+    throw new CliError({
+      code: "INTERNAL",
+      message: "Unable to determine the current executable entrypoint (process.argv is incomplete)",
+      exitCode: 1,
+      details: { argv: process.argv }
+    });
+  }
+  const execArgv = Array.isArray(process.execArgv) ? process.execArgv : [];
+  const args2 = [...execArgv, script, "--daemon-url", params3.wsUrl, "--store-db", params3.storeDb];
+  if (params3.remnoteDb)
+    args2.push("--remnote-db", params3.remnoteDb);
+  args2.push("--api-base-path", params3.basePath);
+  args2.push("api", "serve", "--host", params3.host, "--port", String(params3.port), "--state-file", params3.stateFile);
+  return { command, args: args2 };
+}
+function toPidFileValue(params3) {
+  return {
+    pid: params3.pid,
+    build: currentRuntimeBuildInfo(),
+    started_at: params3.startedAt,
+    host: params3.host,
+    port: params3.port,
+    base_path: params3.basePath,
+    log_file: params3.logFile,
+    state_file: params3.stateFile,
+    cmd: params3.cmd
+  };
+}
+function waitForApiHealth(baseUrl, waitMs) {
+  return gen2(function* () {
+    if (!Number.isFinite(waitMs) || waitMs < 0) {
+      return yield* fail8(new CliError({
+        code: "INVALID_ARGS",
+        message: "--wait must be a non-negative integer (ms)",
+        exitCode: 2,
+        details: { wait_ms: waitMs }
+      }));
+    }
+    if (waitMs === 0)
+      return;
+    const api = yield* HostApiClient;
+    const deadline = Date.now() + waitMs;
+    while (Date.now() < deadline) {
+      const remaining = Math.max(0, deadline - Date.now());
+      const res = yield* api.health({ baseUrl, timeoutMs: Math.min(API_HEALTH_TIMEOUT_MS, Math.max(1, remaining)) }).pipe(either3);
+      if (isRight2(res))
+        return;
+      yield* sleep4(millis(300));
+    }
+    return yield* fail8(new CliError({
+      code: "API_TIMEOUT",
+      message: `Timed out waiting for host API to become available (${waitMs}ms)`,
+      exitCode: 1,
+      details: { base_url: baseUrl, wait_ms: waitMs },
+      hint: ["agent-remnote api status --json", "agent-remnote api logs", "agent-remnote stack status --json"]
+    }));
+  });
+}
+function startApiDaemon(params3) {
+  return gen2(function* () {
+    const cfg = yield* AppConfig;
+    const api = yield* HostApiClient;
+    const apiFiles = yield* ApiDaemonFiles;
+    const proc = yield* Process;
+    const host = params3.host ?? cfg.apiHost ?? "0.0.0.0";
+    const port3 = params3.port ?? cfg.apiPort ?? 3000;
+    const basePath = params3.basePath ?? cfg.apiBasePath ?? "/v1";
+    const pidFilePath = resolveUserFilePath(params3.pidFile ?? apiFiles.defaultPidFile());
+    const logFilePath = resolveUserFilePath(params3.logFile ?? apiFiles.defaultLogFile());
+    const stateFilePath = resolveUserFilePath(params3.stateFile ?? apiFiles.defaultStateFile());
+    const localBaseUrl = apiLocalBaseUrl(port3, basePath);
+    const existing = yield* apiFiles.readPidFile(pidFilePath);
+    if (existing) {
+      const alive = yield* proc.isPidRunning(existing.pid);
+      if (!alive) {
+        yield* apiFiles.deletePidFile(pidFilePath);
+      } else {
+        yield* requireTrustedPidRecord({ record: existing, pidFilePath });
+        return {
+          started: false,
+          pid: existing.pid,
+          pid_file: pidFilePath,
+          log_file: logFilePath,
+          state_file: stateFilePath,
+          base_url: localBaseUrl
+        };
+      }
+    }
+    const pre = yield* api.health({ baseUrl: localBaseUrl, timeoutMs: API_HEALTH_TIMEOUT_MS }).pipe(either3);
+    if (isRight2(pre)) {
+      return {
+        started: false,
+        pid_file: pidFilePath,
+        log_file: logFilePath,
+        state_file: stateFilePath,
+        base_url: localBaseUrl
+      };
+    }
+    const cmd = yield* try_3({
+      try: () => childCommandLine({
+        wsUrl: cfg.wsUrl,
+        storeDb: cfg.storeDb,
+        remnoteDb: cfg.remnoteDb,
+        host,
+        port: port3,
+        basePath,
+        stateFile: stateFilePath
+      }),
+      catch: (e) => isCliError(e) ? e : new CliError({
+        code: "INTERNAL",
+        message: "Failed to start host api",
+        exitCode: 1,
+        details: { error: String(e?.message || e) }
+      })
+    });
+    const pid = yield* proc.spawnDetached({ command: cmd.command, args: cmd.args, logFile: logFilePath });
+    yield* apiFiles.writePidFile(pidFilePath, toPidFileValue({
+      pid,
+      startedAt: Date.now(),
+      host,
+      port: port3,
+      basePath,
+      logFile: logFilePath,
+      stateFile: stateFilePath,
+      cmd: [cmd.command, ...cmd.args]
+    }));
+    yield* waitForApiHealth(localBaseUrl, params3.waitMs);
+    return {
+      started: true,
+      pid,
+      pid_file: pidFilePath,
+      log_file: logFilePath,
+      state_file: stateFilePath,
+      base_url: localBaseUrl
+    };
+  });
+}
+function ensureApiDaemon(params3) {
+  return gen2(function* () {
+    const cfg = yield* AppConfig;
+    const api = yield* HostApiClient;
+    const apiFiles = yield* ApiDaemonFiles;
+    const proc = yield* Process;
+    const port3 = params3.port ?? cfg.apiPort ?? 3000;
+    const basePath = cfg.apiBasePath ?? "/v1";
+    const pidFilePath = resolveUserFilePath(params3.pidFile ?? apiFiles.defaultPidFile());
+    const logFilePath = resolveUserFilePath(params3.logFile ?? apiFiles.defaultLogFile());
+    const stateFilePath = resolveUserFilePath(params3.stateFile ?? apiFiles.defaultStateFile());
+    const localBaseUrl = apiLocalBaseUrl(port3, basePath);
+    const pre = yield* api.health({ baseUrl: localBaseUrl, timeoutMs: API_HEALTH_TIMEOUT_MS }).pipe(either3);
+    if (isRight2(pre)) {
+      const existing = yield* apiFiles.readPidFile(pidFilePath);
+      if (existing) {
+        const alive = yield* proc.isPidRunning(existing.pid);
+        if (alive) {
+          yield* requireTrustedPidRecord({ record: existing, pidFilePath });
+          return {
+            started: false,
+            pid: existing.pid,
+            pid_file: pidFilePath,
+            log_file: existing.log_file ?? logFilePath,
+            state_file: existing.state_file ?? stateFilePath,
+            base_url: localBaseUrl
+          };
+        }
+      }
+      return {
+        started: false,
+        pid_file: pidFilePath,
+        log_file: logFilePath,
+        state_file: stateFilePath,
+        base_url: localBaseUrl
+      };
+    }
+    return yield* startApiDaemon(params3);
+  });
+}
+
+// src/lib/pluginServerHealth.ts
+function checkPluginServerHealth(baseUrl, timeoutMs) {
+  return tryPromise2({
+    try: async () => {
+      const controller = new AbortController;
+      const timer2 = setTimeout(() => controller.abort(), timeoutMs);
+      try {
+        const res = await fetch(`${baseUrl}/manifest.json`, { signal: controller.signal });
+        if (!res.ok) {
+          throw new Error(`Unexpected response status: ${res.status}`);
+        }
+        return { base_url: baseUrl };
+      } finally {
+        clearTimeout(timer2);
+      }
+    },
+    catch: (error4) => new CliError({
+      code: "PLUGIN_UNAVAILABLE",
+      message: "Plugin server is unavailable",
+      exitCode: 1,
+      details: { base_url: baseUrl, error: String(error4?.message || error4) }
+    })
+  });
+}
+function waitForPluginServerHealth(baseUrl, waitMs, timeoutMs) {
+  return gen2(function* () {
+    if (!Number.isFinite(waitMs) || waitMs < 0) {
+      return yield* fail8(new CliError({
+        code: "INVALID_ARGS",
+        message: "--wait must be a non-negative integer (ms)",
+        exitCode: 2,
+        details: { wait_ms: waitMs }
+      }));
+    }
+    if (waitMs === 0)
+      return;
+    const deadline = Date.now() + waitMs;
+    while (Date.now() < deadline) {
+      const remaining = Math.max(0, deadline - Date.now());
+      const res = yield* checkPluginServerHealth(baseUrl, Math.min(timeoutMs, Math.max(1, remaining))).pipe(either3);
+      if (isRight2(res))
+        return;
+      yield* sleep4(millis(300));
+    }
+    return yield* fail8(new CliError({
+      code: "PLUGIN_UNAVAILABLE",
+      message: `Timed out waiting for plugin server to become available (${waitMs}ms)`,
+      exitCode: 1,
+      details: { base_url: baseUrl, wait_ms: waitMs },
+      hint: ["agent-remnote plugin status --json", "agent-remnote plugin logs --lines 200"]
+    }));
+  });
+}
+
+// src/commands/plugin/_shared.ts
+var PLUGIN_SERVER_HEALTH_TIMEOUT_MS = 2000;
+var PLUGIN_SERVER_START_WAIT_DEFAULT_MS = 15000;
+var PLUGIN_SERVER_STOP_WAIT_DEFAULT_MS = 5000;
+var PLUGIN_SERVER_DEFAULT_HOST = "127.0.0.1";
+var PLUGIN_SERVER_DEFAULT_PORT = 8080;
+function pluginServerLocalBaseUrl(host, port3) {
+  const normalizedHost = host === "0.0.0.0" || host === "::" ? "127.0.0.1" : host;
+  return `http://${normalizedHost}:${port3}`;
+}
+function childCommandLine2(params3) {
+  const command = process.argv[0];
+  const script = process.argv[1];
+  if (!command || !script) {
+    throw new CliError({
+      code: "INTERNAL",
+      message: "Unable to determine the current executable entrypoint (process.argv is incomplete)",
+      exitCode: 1,
+      details: { argv: process.argv }
+    });
+  }
+  const execArgv = Array.isArray(process.execArgv) ? process.execArgv : [];
+  const args2 = [...execArgv, script, "plugin", "serve", "--host", params3.host, "--port", String(params3.port), "--state-file", params3.stateFile];
+  return { command, args: args2 };
+}
+function toPidFileValue2(params3) {
+  return {
+    pid: params3.pid,
+    build: currentRuntimeBuildInfo(),
+    started_at: params3.startedAt,
+    host: params3.host,
+    port: params3.port,
+    log_file: params3.logFile,
+    state_file: params3.stateFile,
+    cmd: params3.cmd
+  };
+}
+function startPluginServer(params3) {
+  return gen2(function* () {
+    const files = yield* PluginServerFiles;
+    const proc = yield* Process;
+    const host = params3.host ?? PLUGIN_SERVER_DEFAULT_HOST;
+    const port3 = params3.port ?? PLUGIN_SERVER_DEFAULT_PORT;
+    const pidFilePath = resolveUserFilePath(params3.pidFile ?? files.defaultPidFile());
+    const logFilePath = resolveUserFilePath(params3.logFile ?? files.defaultLogFile());
+    const stateFilePath = resolveUserFilePath(params3.stateFile ?? files.defaultStateFile());
+    const baseUrl = pluginServerLocalBaseUrl(host, port3);
+    const existing = yield* files.readPidFile(pidFilePath);
+    if (existing) {
+      const alive = yield* proc.isPidRunning(existing.pid);
+      if (!alive) {
+        yield* files.deletePidFile(pidFilePath);
+      } else {
+        yield* requireTrustedPidRecord({ record: existing, pidFilePath });
+        return {
+          started: false,
+          pid: existing.pid,
+          pid_file: pidFilePath,
+          log_file: existing.log_file ?? logFilePath,
+          state_file: existing.state_file ?? stateFilePath,
+          base_url: baseUrl
+        };
+      }
+    }
+    const pre = yield* checkPluginServerHealth(baseUrl, PLUGIN_SERVER_HEALTH_TIMEOUT_MS).pipe(either3);
+    if (isRight2(pre)) {
+      return {
+        started: false,
+        pid_file: pidFilePath,
+        log_file: logFilePath,
+        state_file: stateFilePath,
+        base_url: baseUrl
+      };
+    }
+    const cmd = yield* try_3({
+      try: () => childCommandLine2({ host, port: port3, stateFile: stateFilePath }),
+      catch: (error4) => isCliError(error4) ? error4 : new CliError({
+        code: "INTERNAL",
+        message: "Failed to start plugin server",
+        exitCode: 1,
+        details: { error: String(error4?.message || error4) }
+      })
+    });
+    const pid = yield* proc.spawnDetached({ command: cmd.command, args: cmd.args, logFile: logFilePath });
+    yield* files.writePidFile(pidFilePath, toPidFileValue2({
+      pid,
+      startedAt: Date.now(),
+      host,
+      port: port3,
+      logFile: logFilePath,
+      stateFile: stateFilePath,
+      cmd: [cmd.command, ...cmd.args]
+    }));
+    yield* waitForPluginServerHealth(baseUrl, params3.waitMs, PLUGIN_SERVER_HEALTH_TIMEOUT_MS);
+    return {
+      started: true,
+      pid,
+      pid_file: pidFilePath,
+      log_file: logFilePath,
+      state_file: stateFilePath,
+      base_url: baseUrl
+    };
+  });
+}
+function ensurePluginServer(params3) {
+  return gen2(function* () {
+    const files = yield* PluginServerFiles;
+    const proc = yield* Process;
+    const host = params3.host ?? PLUGIN_SERVER_DEFAULT_HOST;
+    const port3 = params3.port ?? PLUGIN_SERVER_DEFAULT_PORT;
+    const pidFilePath = resolveUserFilePath(params3.pidFile ?? files.defaultPidFile());
+    const logFilePath = resolveUserFilePath(params3.logFile ?? files.defaultLogFile());
+    const stateFilePath = resolveUserFilePath(params3.stateFile ?? files.defaultStateFile());
+    const baseUrl = pluginServerLocalBaseUrl(host, port3);
+    const pre = yield* checkPluginServerHealth(baseUrl, PLUGIN_SERVER_HEALTH_TIMEOUT_MS).pipe(either3);
+    if (isRight2(pre)) {
+      const existing = yield* files.readPidFile(pidFilePath);
+      if (existing) {
+        const alive = yield* proc.isPidRunning(existing.pid);
+        if (alive) {
+          yield* requireTrustedPidRecord({ record: existing, pidFilePath });
+          return {
+            started: false,
+            pid: existing.pid,
+            pid_file: pidFilePath,
+            log_file: existing.log_file ?? logFilePath,
+            state_file: existing.state_file ?? stateFilePath,
+            base_url: baseUrl
+          };
+        }
+      }
+      return {
+        started: false,
+        pid_file: pidFilePath,
+        log_file: logFilePath,
+        state_file: stateFilePath,
+        base_url: baseUrl
+      };
+    }
+    return yield* startPluginServer(params3);
+  });
+}
+
+// src/commands/ws/_shared.ts
+import path21 from "node:path";
+var WS_HEALTH_TIMEOUT_MS = 2000;
+var WS_START_WAIT_DEFAULT_MS = 15000;
+var WS_STOP_WAIT_DEFAULT_MS = 5000;
+function supervisorCommandLine(params3) {
+  const command = process.argv[0];
+  const script = process.argv[1];
+  if (!command || !script) {
+    throw new CliError({
+      code: "INTERNAL",
+      message: "Unable to determine the current executable entrypoint (process.argv is incomplete)",
+      exitCode: 1,
+      details: { argv: process.argv }
+    });
+  }
+  const execArgv = Array.isArray(process.execArgv) ? process.execArgv : [];
+  return {
+    command,
+    args: [
+      ...execArgv,
+      script,
+      "--daemon-url",
+      params3.wsUrl,
+      "--store-db",
+      params3.storeDb,
+      "daemon",
+      "supervisor",
+      "--pid-file",
+      params3.pidFile,
+      "--log-file",
+      params3.logFile,
+      "--state-file",
+      params3.stateFile
+    ]
+  };
+}
+function toPidFileValue3(params3) {
+  return {
+    pid: params3.pid,
+    build: currentRuntimeBuildInfo(),
+    started_at: params3.startedAt,
+    ws_url: params3.wsUrl,
+    log_file: params3.logFile,
+    cmd: params3.cmd,
+    ws_bridge_state_file: params3.wsBridgeStateFile,
+    status_line_file: params3.statusLineFile,
+    status_line_json_file: params3.statusLineJsonFile
+  };
+}
+function waitForHealth(url2, waitMs) {
+  return gen2(function* () {
+    if (!Number.isFinite(waitMs) || waitMs < 0) {
+      return yield* fail8(new CliError({
+        code: "INVALID_ARGS",
+        message: "--wait must be a non-negative integer (ms)",
+        exitCode: 2,
+        details: { wait_ms: waitMs }
+      }));
+    }
+    if (waitMs === 0)
+      return;
+    const ws = yield* WsClient;
+    const deadline = Date.now() + waitMs;
+    while (Date.now() < deadline) {
+      const remaining = Math.max(0, deadline - Date.now());
+      const res = yield* ws.health({ url: url2, timeoutMs: Math.min(WS_HEALTH_TIMEOUT_MS, Math.max(1, remaining)) }).pipe(either3);
+      if (isRight2(res))
+        return;
+      yield* sleep4(millis(300));
+    }
+    return yield* fail8(new CliError({
+      code: "WS_TIMEOUT",
+      message: `Timed out waiting for WS to become available (${waitMs}ms)`,
+      exitCode: 1,
+      details: { url: url2, wait_ms: waitMs },
+      hint: ["agent-remnote daemon status", "agent-remnote daemon logs", "agent-remnote daemon health --json"]
+    }));
+  });
+}
+function toInitialSupervisorState(now2) {
+  return {
+    status: "running",
+    restart_count: 0,
+    restart_window_started_at: now2,
+    backoff_until: null,
+    last_exit: null,
+    failed_reason: null
+  };
+}
+function defaultStateFilePathFromPidFile(pidFilePath) {
+  return path21.join(path21.dirname(pidFilePath), "ws.state.json");
+}
+function startWsSupervisor(params3) {
+  return gen2(function* () {
+    const cfg = yield* AppConfig;
+    const daemonFiles = yield* DaemonFiles;
+    const supervisorState = yield* SupervisorState;
+    const proc = yield* Process;
+    const ws = yield* WsClient;
+    const pidFilePath = resolveUserFilePath(params3.pidFile ?? daemonFiles.defaultPidFile());
+    const logFilePath = resolveUserFilePath(params3.logFile ?? daemonFiles.defaultLogFile());
+    const stateFilePath = defaultStateFilePathFromPidFile(pidFilePath);
+    const existingPidFile = yield* daemonFiles.readPidFile(pidFilePath);
+    if (existingPidFile) {
+      const alive = yield* proc.isPidRunning(existingPidFile.pid);
+      if (!alive) {
+        yield* daemonFiles.deletePidFile(pidFilePath);
+        yield* supervisorState.deleteStateFile(stateFilePath);
+      } else {
+        yield* requireTrustedPidRecord({ record: existingPidFile, pidFilePath });
+        return {
+          started: false,
+          pid: existingPidFile.pid,
+          pid_file: pidFilePath,
+          log_file: existingPidFile.log_file ?? logFilePath
+        };
+      }
+    }
+    const pre = yield* ws.health({ url: cfg.wsUrl, timeoutMs: WS_HEALTH_TIMEOUT_MS }).pipe(either3);
+    if (isRight2(pre)) {
+      return { started: false, pid_file: pidFilePath, log_file: logFilePath };
+    }
+    const cmd = yield* try_3({
+      try: () => supervisorCommandLine({
+        wsUrl: cfg.wsUrl,
+        storeDb: cfg.storeDb,
+        pidFile: pidFilePath,
+        logFile: logFilePath,
+        stateFile: stateFilePath
+      }),
+      catch: (e) => isCliError(e) ? e : new CliError({
+        code: "INTERNAL",
+        message: "Failed to start supervisor",
+        exitCode: 1,
+        details: { error: String(e?.message || e) }
+      })
+    });
+    const pid = yield* proc.spawnDetached({ command: cmd.command, args: cmd.args, logFile: logFilePath });
+    const now2 = Date.now();
+    yield* daemonFiles.writePidFile(pidFilePath, {
+      ...toPidFileValue3({
+        pid,
+        startedAt: now2,
+        wsUrl: cfg.wsUrl,
+        logFile: logFilePath,
+        cmd: [cmd.command, ...cmd.args],
+        wsBridgeStateFile: cfg.wsStateFile.path,
+        statusLineFile: cfg.statusLineFile,
+        statusLineJsonFile: cfg.statusLineJsonFile
+      }),
+      mode: "supervisor",
+      child_pid: null,
+      state_file: stateFilePath
+    });
+    yield* supervisorState.writeStateFile(stateFilePath, toInitialSupervisorState(now2));
+    yield* waitForHealth(cfg.wsUrl, params3.waitMs);
+    return { started: true, pid, pid_file: pidFilePath, log_file: logFilePath };
+  });
+}
+function ensureWsSupervisor(params3) {
+  return gen2(function* () {
+    const cfg = yield* AppConfig;
+    const ws = yield* WsClient;
+    const pre = yield* ws.health({ url: cfg.wsUrl, timeoutMs: WS_HEALTH_TIMEOUT_MS }).pipe(either3);
+    if (isRight2(pre)) {
+      const daemonFiles = yield* DaemonFiles;
+      const proc = yield* Process;
+      const pidFilePath = resolveUserFilePath(params3.pidFile ?? daemonFiles.defaultPidFile());
+      const logFilePath = resolveUserFilePath(params3.logFile ?? daemonFiles.defaultLogFile());
+      const existingPidFile = yield* daemonFiles.readPidFile(pidFilePath);
+      if (existingPidFile) {
+        const alive = yield* proc.isPidRunning(existingPidFile.pid);
+        if (alive) {
+          yield* requireTrustedPidRecord({ record: existingPidFile, pidFilePath });
+          return {
+            started: false,
+            pid: existingPidFile.pid,
+            pid_file: pidFilePath,
+            log_file: existingPidFile.log_file ?? logFilePath
+          };
+        }
+      }
+      return {
+        started: false,
+        pid_file: pidFilePath,
+        log_file: logFilePath
+      };
+    }
+    return yield* startWsSupervisor(params3);
+  });
+}
+
+// src/lib/managedRuntimePaths.ts
+import path22 from "node:path";
+function resolveManagedStateFile(params3) {
+  const defaultPath = resolveUserFilePath(params3.defaultStateFilePath);
+  const explicitPath = params3.explicitStateFilePath ? resolveUserFilePath(params3.explicitStateFilePath) : undefined;
+  const candidatePath = params3.candidate ? resolveUserFilePath(params3.candidate) : undefined;
+  if (!candidatePath) {
+    return explicitPath ?? defaultPath;
+  }
+  if (candidatePath === defaultPath)
+    return candidatePath;
+  if (explicitPath && candidatePath === explicitPath)
+    return candidatePath;
+  const pidRoot = path22.dirname(params3.pidFilePath);
+  const rel = path22.relative(pidRoot, candidatePath);
+  if (rel === "" || !rel.startsWith("..") && !path22.isAbsolute(rel)) {
+    return candidatePath;
+  }
+  return explicitPath ?? defaultPath;
+}
+
+// src/lib/pluginBuildInfo.ts
+import { readFileSync as readFileSync3 } from "node:fs";
+import path24 from "node:path";
+
+// src/lib/pluginArtifacts.ts
+import { existsSync as existsSync3, statSync as statSync2 } from "node:fs";
+import path23 from "node:path";
+import { fileURLToPath as fileURLToPath4 } from "node:url";
+function currentDir(moduleUrl) {
+  return path23.dirname(fileURLToPath4(moduleUrl));
+}
+function isDirectory(targetPath) {
+  try {
+    return statSync2(targetPath).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function isFile(targetPath) {
+  try {
+    return statSync2(targetPath).isFile();
+  } catch {
+    return false;
+  }
+}
+function distCandidates(moduleUrl) {
+  const dir2 = currentDir(moduleUrl);
+  return [
+    path23.resolve(dir2, "../../plugin-artifacts/dist"),
+    path23.resolve(dir2, "../plugin-artifacts/dist"),
+    path23.resolve(dir2, "../../../plugin/dist"),
+    path23.resolve(dir2, "../../plugin/dist")
+  ];
+}
+function zipCandidates(moduleUrl) {
+  const dir2 = currentDir(moduleUrl);
+  return [
+    path23.resolve(dir2, "../../plugin-artifacts/PluginZip.zip"),
+    path23.resolve(dir2, "../plugin-artifacts/PluginZip.zip"),
+    path23.resolve(dir2, "../../../plugin/PluginZip.zip"),
+    path23.resolve(dir2, "../../plugin/PluginZip.zip")
+  ];
+}
+function validateDistPath(targetPath) {
+  return isDirectory(targetPath) && existsSync3(path23.join(targetPath, "manifest.json"));
+}
+function hasBuildInfo(targetPath) {
+  return isFile(path23.join(targetPath, "build-info.json"));
+}
+function resolvePluginDistPath(moduleUrl = import.meta.url) {
+  for (const candidate of distCandidates(moduleUrl)) {
+    if (validateDistPath(candidate) && hasBuildInfo(candidate))
+      return candidate;
+  }
+  for (const candidate of distCandidates(moduleUrl)) {
+    if (validateDistPath(candidate))
+      return candidate;
+  }
+  throw new CliError({
+    code: "DEPENDENCY_MISSING",
+    message: "Plugin build artifacts are unavailable",
+    exitCode: 1,
+    details: { candidates: distCandidates(moduleUrl) },
+    hint: [
+      "Run npm run build --workspace @remnote/plugin in the repository checkout",
+      "Or install a packaged agent-remnote release that includes plugin artifacts"
+    ]
+  });
+}
+function resolvePluginZipPath(moduleUrl = import.meta.url) {
+  for (const candidate of zipCandidates(moduleUrl)) {
+    if (isFile(candidate))
+      return candidate;
+  }
+  throw new CliError({
+    code: "DEPENDENCY_MISSING",
+    message: "Plugin zip artifact is unavailable",
+    exitCode: 1,
+    details: { candidates: zipCandidates(moduleUrl) },
+    hint: [
+      "Run npm run build --workspace @remnote/plugin in the repository checkout",
+      "Or install a packaged agent-remnote release that includes plugin artifacts"
+    ]
+  });
+}
+
+// src/lib/pluginBuildInfo.ts
+function readPluginDistBuildInfo(distPath) {
+  const normalized = typeof distPath === "string" ? distPath.trim() : "";
+  if (!normalized)
+    return null;
+  const target2 = path24.join(normalized, "build-info.json");
+  try {
+    const raw4 = readFileSync3(target2, "utf8");
+    const parsed = JSON.parse(raw4);
+    if (typeof parsed?.name === "string" && typeof parsed?.version === "string" && typeof parsed?.build_id === "string" && typeof parsed?.built_at === "number" && typeof parsed?.source_stamp === "number") {
+      return {
+        name: parsed.name,
+        version: parsed.version,
+        build_id: parsed.build_id,
+        built_at: parsed.built_at,
+        source_stamp: parsed.source_stamp,
+        mode: parsed.mode === "src" || parsed.mode === "dist" || parsed.mode === "unknown" ? parsed.mode : "dist"
+      };
+    }
+  } catch {}
+  return null;
+}
+function currentExpectedPluginBuildInfo() {
+  try {
+    const dist = resolvePluginDistPath();
+    return readPluginDistBuildInfo(dist);
+  } catch {
+    return null;
+  }
+}
+function pluginBuildWarnings(params3) {
+  if (!params3.expected || !params3.live)
+    return [];
+  if (params3.expected.build_id === params3.live.build_id)
+    return [];
+  return [
+    `plugin build mismatch: expected=${params3.expected.build_id} live=${params3.live.build_id}`
+  ];
+}
+
+// src/lib/statuslineArtifacts.ts
+import { promises as fs15 } from "node:fs";
+
+// src/services/StatusLineFile.ts
+import { promises as fs14 } from "node:fs";
+import path25 from "node:path";
+class StatusLineFile extends Tag2("StatusLineFile")() {
+}
+function defaultTextFile() {
+  return path25.join(homeDir(), ".agent-remnote", "status-line.txt");
+}
+function defaultJsonFile() {
+  return path25.join(homeDir(), ".agent-remnote", "status-line.json");
+}
+function ensureDir8(p3) {
+  return fs14.mkdir(path25.dirname(p3), { recursive: true }).then(() => {
+    return;
+  });
+}
+async function readFileOrEmpty(filePath) {
+  try {
+    return await fs14.readFile(filePath, "utf8");
+  } catch (e) {
+    if (e?.code === "ENOENT")
+      return "";
+    throw e;
   }
 }
 async function writeTextAtomic(filePath, content) {
@@ -92544,6 +93588,26 @@ function cleanupStatuslineArtifacts(paths) {
 }
 
 // src/lib/doctor/fixes.ts
+function stopTrustedRuntime(params3) {
+  return gen2(function* () {
+    const proc = yield* Process;
+    yield* proc.kill(params3.pid, "SIGTERM");
+    const exited = yield* proc.waitForExit({ pid: params3.pid, timeoutMs: params3.stopWaitMs });
+    if (!exited) {
+      yield* proc.kill(params3.pid, "SIGKILL");
+      const killed = yield* proc.waitForExit({ pid: params3.pid, timeoutMs: params3.stopWaitMs });
+      if (!killed) {
+        return yield* fail8(new CliError({
+          code: "INTERNAL",
+          message: `Failed to stop mismatched ${params3.service} runtime`,
+          exitCode: 1,
+          details: { pid: params3.pid, pid_file: params3.pidFilePath, state_file: params3.stateFilePath }
+        }));
+      }
+    }
+    yield* params3.cleanup;
+  });
+}
 function applyDoctorFixes() {
   return gen2(function* () {
     const cfg = yield* AppConfig;
@@ -92557,6 +93621,7 @@ function applyDoctorFixes() {
     const fixes = [];
     const cleaned = [];
     const cleanupFailures = [];
+    const current2 = currentRuntimeBuildInfo();
     const daemonPidFile = daemonFiles.defaultPidFile();
     const daemonPidInfo = yield* daemonFiles.readPidFile(daemonPidFile).pipe(orElseSucceed2(() => {
       return;
@@ -92639,6 +93704,14 @@ function applyDoctorFixes() {
         });
       }
     }
+    const resolvedPluginStateFile = resolveManagedStateFile({
+      pidFilePath: pluginPidFile,
+      defaultStateFilePath: pluginFiles.defaultStateFile(),
+      candidate: pluginPidInfo?.state_file
+    });
+    const pluginStateInfo = yield* pluginFiles.readStateFile(resolvedPluginStateFile).pipe(orElseSucceed2(() => {
+      return;
+    }));
     fixes.push({
       id: "runtime.cleanup_stale_artifacts",
       ok: cleanupFailures.length === 0,
@@ -92673,17 +93746,155 @@ function applyDoctorFixes() {
         details: { error: configRepair.left.message }
       });
     }
+    const restartAttempted = [];
+    const restartRestarted = [];
+    const restartSkipped = [];
+    const restartFailed = [];
+    const expectedPlugin = currentExpectedPluginBuildInfo();
+    const daemonNeedsRestart = daemonPidInfo?.pid && daemonPidInfo.build?.build_id && daemonPidInfo.build.build_id !== current2.build_id && daemonPidInfo.mode === "supervisor" && (yield* isTrustedPidRecord(daemonPidInfo));
+    if (daemonNeedsRestart) {
+      const daemonStateFile = resolveManagedStateFile({
+        pidFilePath: daemonPidFile,
+        defaultStateFilePath: supervisorState.defaultStateFile(),
+        candidate: daemonPidInfo.state_file
+      });
+      restartAttempted.push("daemon");
+      const stopped = yield* stopTrustedRuntime({
+        service: "daemon",
+        pid: daemonPidInfo.pid,
+        pidFilePath: daemonPidFile,
+        stateFilePath: daemonStateFile,
+        stopWaitMs: WS_STOP_WAIT_DEFAULT_MS,
+        cleanup: gen2(function* () {
+          yield* daemonFiles.deletePidFile(daemonPidFile);
+          yield* supervisorState.deleteStateFile(daemonStateFile);
+          yield* cleanupStatuslineArtifacts(resolveStatuslineArtifactPaths({ cfg, pidInfo: daemonPidInfo }));
+        })
+      }).pipe(either3);
+      if (stopped._tag === "Right") {
+        changed = true;
+        const started = yield* startWsSupervisor({
+          waitMs: WS_START_WAIT_DEFAULT_MS,
+          pidFile: daemonPidFile,
+          logFile: daemonPidInfo.log_file
+        }).pipe(either3);
+        if (started._tag === "Right") {
+          if (started.right.started) {
+            restartRestarted.push("daemon");
+          } else {
+            restartSkipped.push("daemon_already_healthy_after_restart_attempt");
+          }
+        } else {
+          restartFailed.push({ service: "daemon", error: started.left.message });
+        }
+      } else {
+        restartFailed.push({ service: "daemon", error: stopped.left.message });
+      }
+    } else if (daemonPidInfo?.build?.build_id && daemonPidInfo.build.build_id !== current2.build_id) {
+      restartSkipped.push("daemon_restart_not_safe");
+    }
+    const apiNeedsRestart = apiPidInfo?.pid && apiPidInfo.build?.build_id && apiPidInfo.build.build_id !== current2.build_id && (yield* isTrustedPidRecord(apiPidInfo));
+    if (apiNeedsRestart) {
+      const apiStateFile = resolveManagedStateFile({
+        pidFilePath: apiPidFile,
+        defaultStateFilePath: apiFiles.defaultStateFile(),
+        candidate: apiPidInfo.state_file
+      });
+      restartAttempted.push("api");
+      const stopped = yield* stopTrustedRuntime({
+        service: "api",
+        pid: apiPidInfo.pid,
+        pidFilePath: apiPidFile,
+        stateFilePath: apiStateFile,
+        stopWaitMs: API_STOP_WAIT_DEFAULT_MS,
+        cleanup: gen2(function* () {
+          yield* apiFiles.deletePidFile(apiPidFile);
+          yield* apiFiles.deleteStateFile(apiStateFile);
+        })
+      }).pipe(either3);
+      if (stopped._tag === "Right") {
+        changed = true;
+        const started = yield* startApiDaemon({
+          host: apiPidInfo.host,
+          port: apiPidInfo.port,
+          basePath: apiPidInfo.base_path,
+          waitMs: API_START_WAIT_DEFAULT_MS,
+          pidFile: apiPidFile,
+          logFile: apiPidInfo.log_file,
+          stateFile: apiStateFile
+        }).pipe(either3);
+        if (started._tag === "Right") {
+          if (started.right.started) {
+            restartRestarted.push("api");
+          } else {
+            restartSkipped.push("api_already_healthy_after_restart_attempt");
+          }
+        } else {
+          restartFailed.push({ service: "api", error: started.left.message });
+        }
+      } else {
+        restartFailed.push({ service: "api", error: stopped.left.message });
+      }
+    } else if (apiPidInfo?.build?.build_id && apiPidInfo.build.build_id !== current2.build_id) {
+      restartSkipped.push("api_restart_not_safe");
+    }
+    const pluginArtifactMismatch = expectedPlugin && pluginStateInfo?.plugin_build?.build_id && pluginStateInfo.plugin_build.build_id !== expectedPlugin.build_id;
+    const pluginRuntimeMismatch = pluginPidInfo?.build?.build_id && pluginPidInfo.build.build_id !== current2.build_id;
+    const pluginNeedsRestart = pluginPidInfo?.pid && (pluginRuntimeMismatch || pluginArtifactMismatch) && (yield* isTrustedPidRecord(pluginPidInfo));
+    if (pluginNeedsRestart) {
+      const pluginStateFile = resolveManagedStateFile({
+        pidFilePath: pluginPidFile,
+        defaultStateFilePath: pluginFiles.defaultStateFile(),
+        candidate: pluginPidInfo.state_file
+      });
+      restartAttempted.push("plugin");
+      const stopped = yield* stopTrustedRuntime({
+        service: "plugin",
+        pid: pluginPidInfo.pid,
+        pidFilePath: pluginPidFile,
+        stateFilePath: pluginStateFile,
+        stopWaitMs: PLUGIN_SERVER_STOP_WAIT_DEFAULT_MS,
+        cleanup: gen2(function* () {
+          yield* pluginFiles.deletePidFile(pluginPidFile);
+          yield* pluginFiles.deleteStateFile(pluginStateFile);
+        })
+      }).pipe(either3);
+      if (stopped._tag === "Right") {
+        changed = true;
+        const started = yield* startPluginServer({
+          host: pluginPidInfo.host,
+          port: pluginPidInfo.port,
+          waitMs: PLUGIN_SERVER_START_WAIT_DEFAULT_MS,
+          pidFile: pluginPidFile,
+          logFile: pluginPidInfo.log_file,
+          stateFile: pluginStateFile
+        }).pipe(either3);
+        if (started._tag === "Right") {
+          if (started.right.started) {
+            restartRestarted.push("plugin");
+          } else {
+            restartSkipped.push("plugin_already_healthy_after_restart_attempt");
+          }
+        } else {
+          restartFailed.push({ service: "plugin", error: started.left.message });
+        }
+      } else {
+        restartFailed.push({ service: "plugin", error: stopped.left.message });
+      }
+    } else if (pluginRuntimeMismatch || pluginArtifactMismatch) {
+      restartSkipped.push("plugin_restart_not_safe");
+    }
     const restartSummary = {
-      attempted: [],
-      restarted: [],
-      skipped: ["safe_restart_disabled"],
-      failed: []
+      attempted: restartAttempted,
+      restarted: restartRestarted,
+      skipped: restartSkipped,
+      failed: restartFailed
     };
     fixes.push({
       id: "runtime.restart_mismatched_services",
-      ok: true,
-      changed: false,
-      summary: "Skipped automatic runtime restart inside doctor --fix to preserve the safe repair boundary",
+      ok: restartFailed.length === 0,
+      changed: restartRestarted.length > 0,
+      summary: restartAttempted.length === 0 ? "No trusted runtime build mismatches required automatic restart" : restartFailed.length === 0 ? `Restarted ${restartRestarted.length} mismatched runtime service(s)` : `Restarted ${restartRestarted.length} mismatched runtime service(s); ${restartFailed.length} restart(s) failed`,
       details: restartSummary
     });
     return { fixes, changed, restartSummary };
@@ -92691,40 +93902,40 @@ function applyDoctorFixes() {
 }
 
 // src/lib/doctor/checks.ts
-import path26 from "node:path";
+import path27 from "node:path";
 
 // src/lib/builtin-scenarios/index.ts
-import { existsSync as existsSync2, readFileSync as readFileSync2 } from "node:fs";
-import path22 from "node:path";
-import { fileURLToPath as fileURLToPath3 } from "node:url";
-var MODULE_DIR = path22.dirname(fileURLToPath3(import.meta.url));
+import { existsSync as existsSync4, readFileSync as readFileSync4 } from "node:fs";
+import path26 from "node:path";
+import { fileURLToPath as fileURLToPath5 } from "node:url";
+var MODULE_DIR = path26.dirname(fileURLToPath5(import.meta.url));
 function locateBuiltinSourceRoot() {
   const packageRootCandidates = [
-    path22.resolve(MODULE_DIR, "../../../"),
-    path22.resolve(MODULE_DIR, "..")
+    path26.resolve(MODULE_DIR, "../../../"),
+    path26.resolve(MODULE_DIR, "..")
   ];
   for (const packageRoot of packageRootCandidates) {
-    const builtinSourceRoot = path22.join(packageRoot, "builtin-scenarios");
-    if (existsSync2(path22.join(builtinSourceRoot, "catalog.json"))) {
+    const builtinSourceRoot = path26.join(packageRoot, "builtin-scenarios");
+    if (existsSync4(path26.join(builtinSourceRoot, "catalog.json"))) {
       return { packageRoot, builtinSourceRoot };
     }
   }
   throw new Error(`Unable to locate builtin-scenarios catalog from ${MODULE_DIR}`);
 }
 var { packageRoot: PACKAGE_ROOT, builtinSourceRoot: BUILTIN_SOURCE_ROOT } = locateBuiltinSourceRoot();
-var REPO_ROOT = path22.resolve(PACKAGE_ROOT, "../..");
-var BUILTIN_CATALOG_PATH = path22.join(BUILTIN_SOURCE_ROOT, "catalog.json");
+var REPO_ROOT = path26.resolve(PACKAGE_ROOT, "../..");
+var BUILTIN_CATALOG_PATH = path26.join(BUILTIN_SOURCE_ROOT, "catalog.json");
 var BUILTIN_SOURCE_PREFIX = "packages/agent-remnote/builtin-scenarios/";
 function readJsonFile(filePath) {
-  return JSON.parse(readFileSync2(filePath, "utf8"));
+  return JSON.parse(readFileSync4(filePath, "utf8"));
 }
 function resolveRepoPath(relPath) {
-  return path22.resolve(REPO_ROOT, relPath);
+  return path26.resolve(REPO_ROOT, relPath);
 }
 function resolveBuiltinPackagePath(relPath) {
   const normalized = relPath.replaceAll("\\", "/");
   if (normalized.startsWith(BUILTIN_SOURCE_PREFIX)) {
-    return path22.resolve(BUILTIN_SOURCE_ROOT, normalized.slice(BUILTIN_SOURCE_PREFIX.length));
+    return path26.resolve(BUILTIN_SOURCE_ROOT, normalized.slice(BUILTIN_SOURCE_PREFIX.length));
   }
   return resolveRepoPath(relPath);
 }
@@ -92732,275 +93943,34 @@ var builtinScenarioCatalog = readJsonFile(BUILTIN_CATALOG_PATH);
 var builtinScenarioPackageCache = new Map;
 var builtinScenarioPackagesTarget = {};
 function loadBuiltinScenarioPackage(entry) {
-  const cached4 = builtinScenarioPackageCache.get(entry.package_id);
-  if (cached4)
-    return cached4;
+  const cached5 = builtinScenarioPackageCache.get(entry.package_id);
+  if (cached5)
+    return cached5;
   const loaded = readJsonFile(resolveBuiltinPackagePath(entry.package_path));
   builtinScenarioPackageCache.set(entry.package_id, loaded);
   return loaded;
 }
-for (const entry of builtinScenarioCatalog) {
-  Object.defineProperty(builtinScenarioPackagesTarget, entry.package_id, {
-    enumerable: true,
-    configurable: false,
-    get: () => loadBuiltinScenarioPackage(entry)
-  });
-}
-var builtinScenarioPackages = Object.freeze(builtinScenarioPackagesTarget);
-function getBuiltinScenarioPackage(id2) {
-  const entry = builtinScenarioCatalog.find((item) => item.package_id === id2);
-  if (!entry) {
-    throw new Error(`Unknown builtin scenario package: ${id2}`);
-  }
-  return loadBuiltinScenarioPackage(entry);
-}
-function getBuiltinScenarioPackageSourcePath(id2) {
-  const entry = builtinScenarioCatalog.find((item) => item.package_id === id2);
-  if (!entry) {
-    throw new Error(`Unknown builtin scenario source: ${id2}`);
-  }
-  return resolveBuiltinPackagePath(entry.package_path);
-}
-
-// src/lib/pluginBuildInfo.ts
-import { readFileSync as readFileSync3 } from "node:fs";
-import path24 from "node:path";
-
-// src/lib/pluginArtifacts.ts
-import { existsSync as existsSync3, statSync } from "node:fs";
-import path23 from "node:path";
-import { fileURLToPath as fileURLToPath4 } from "node:url";
-function currentDir(moduleUrl) {
-  return path23.dirname(fileURLToPath4(moduleUrl));
-}
-function isDirectory(targetPath) {
-  try {
-    return statSync(targetPath).isDirectory();
-  } catch {
-    return false;
-  }
-}
-function isFile(targetPath) {
-  try {
-    return statSync(targetPath).isFile();
-  } catch {
-    return false;
-  }
-}
-function distCandidates(moduleUrl) {
-  const dir2 = currentDir(moduleUrl);
-  return [
-    path23.resolve(dir2, "../../plugin-artifacts/dist"),
-    path23.resolve(dir2, "../plugin-artifacts/dist"),
-    path23.resolve(dir2, "../../../plugin/dist"),
-    path23.resolve(dir2, "../../plugin/dist")
-  ];
-}
-function zipCandidates(moduleUrl) {
-  const dir2 = currentDir(moduleUrl);
-  return [
-    path23.resolve(dir2, "../../plugin-artifacts/PluginZip.zip"),
-    path23.resolve(dir2, "../plugin-artifacts/PluginZip.zip"),
-    path23.resolve(dir2, "../../../plugin/PluginZip.zip"),
-    path23.resolve(dir2, "../../plugin/PluginZip.zip")
-  ];
-}
-function validateDistPath(targetPath) {
-  return isDirectory(targetPath) && existsSync3(path23.join(targetPath, "manifest.json"));
-}
-function hasBuildInfo(targetPath) {
-  return isFile(path23.join(targetPath, "build-info.json"));
-}
-function resolvePluginDistPath(moduleUrl = import.meta.url) {
-  for (const candidate of distCandidates(moduleUrl)) {
-    if (validateDistPath(candidate) && hasBuildInfo(candidate))
-      return candidate;
-  }
-  for (const candidate of distCandidates(moduleUrl)) {
-    if (validateDistPath(candidate))
-      return candidate;
-  }
-  throw new CliError({
-    code: "DEPENDENCY_MISSING",
-    message: "Plugin build artifacts are unavailable",
-    exitCode: 1,
-    details: { candidates: distCandidates(moduleUrl) },
-    hint: [
-      "Run npm run build --workspace @remnote/plugin in the repository checkout",
-      "Or install a packaged agent-remnote release that includes plugin artifacts"
-    ]
-  });
-}
-function resolvePluginZipPath(moduleUrl = import.meta.url) {
-  for (const candidate of zipCandidates(moduleUrl)) {
-    if (isFile(candidate))
-      return candidate;
-  }
-  throw new CliError({
-    code: "DEPENDENCY_MISSING",
-    message: "Plugin zip artifact is unavailable",
-    exitCode: 1,
-    details: { candidates: zipCandidates(moduleUrl) },
-    hint: [
-      "Run npm run build --workspace @remnote/plugin in the repository checkout",
-      "Or install a packaged agent-remnote release that includes plugin artifacts"
-    ]
-  });
-}
-
-// src/lib/pluginBuildInfo.ts
-function readPluginDistBuildInfo(distPath) {
-  const normalized = typeof distPath === "string" ? distPath.trim() : "";
-  if (!normalized)
-    return null;
-  const target2 = path24.join(normalized, "build-info.json");
-  try {
-    const raw4 = readFileSync3(target2, "utf8");
-    const parsed = JSON.parse(raw4);
-    if (typeof parsed?.name === "string" && typeof parsed?.version === "string" && typeof parsed?.build_id === "string" && typeof parsed?.built_at === "number" && typeof parsed?.source_stamp === "number") {
-      return {
-        name: parsed.name,
-        version: parsed.version,
-        build_id: parsed.build_id,
-        built_at: parsed.built_at,
-        source_stamp: parsed.source_stamp,
-        mode: parsed.mode === "src" || parsed.mode === "dist" || parsed.mode === "unknown" ? parsed.mode : "dist"
-      };
-    }
-  } catch {}
-  return null;
-}
-function currentExpectedPluginBuildInfo() {
-  try {
-    const dist = resolvePluginDistPath();
-    return readPluginDistBuildInfo(dist);
-  } catch {
-    return null;
-  }
-}
-function pluginBuildWarnings(params3) {
-  if (!params3.expected || !params3.live)
-    return [];
-  if (params3.expected.build_id === params3.live.build_id)
-    return [];
-  return [
-    `plugin build mismatch: expected=${params3.expected.build_id} live=${params3.live.build_id}`
-  ];
-}
-
-// src/lib/runtimeBuildInfo.ts
-import { createHash as createHash3 } from "node:crypto";
-import { existsSync as existsSync4, readFileSync as readFileSync4, readdirSync, statSync as statSync2 } from "node:fs";
-import path25 from "node:path";
-import { fileURLToPath as fileURLToPath5 } from "node:url";
-function packageInfo() {
-  try {
-    const raw4 = readFileSync4(new URL("../../package.json", import.meta.url), "utf8");
-    const parsed = JSON.parse(raw4);
-    const name = typeof parsed?.name === "string" && parsed.name.trim() ? parsed.name.trim() : "agent-remnote";
-    const version = typeof parsed?.version === "string" && parsed.version.trim() ? parsed.version.trim() : "0.0.0";
-    return { name, version };
-  } catch {
-    return { name: "agent-remnote", version: "0.0.0" };
-  }
-}
-function fileMtimeMs(targetPath) {
-  try {
-    return Math.floor(statSync2(targetPath).mtimeMs);
-  } catch {
-    return 0;
-  }
-}
-function latestMtimeMs(dirPath) {
-  if (!existsSync4(dirPath))
-    return 0;
-  let max7 = 0;
-  const stack = [dirPath];
-  while (stack.length > 0) {
-    const current2 = stack.pop();
-    let entries2 = [];
-    try {
-      entries2 = readdirSync(current2);
-    } catch {
-      continue;
-    }
-    for (const entry of entries2) {
-      const full = path25.join(current2, entry);
-      let st;
-      try {
-        st = statSync2(full);
-      } catch {
-        continue;
-      }
-      if (st.isDirectory()) {
-        stack.push(full);
-      } else if (st.isFile()) {
-        max7 = Math.max(max7, Math.floor(st.mtimeMs));
-      }
-    }
-  }
-  return max7;
-}
-function detectMode() {
-  const url2 = import.meta.url;
-  if (url2.includes("/src/"))
-    return "src";
-  if (url2.includes("/dist/"))
-    return "dist";
-  return "unknown";
-}
-function computeDefaultBuildInfo() {
-  const pkg = packageInfo();
-  const mode = detectMode();
-  const srcDir = new URL("../", import.meta.url);
-  const packageJson = new URL("../../package.json", import.meta.url);
-  const sourceStamp = Math.max(latestMtimeMs(fileURLToPath5(srcDir)), fileMtimeMs(fileURLToPath5(packageJson)));
-  const buildIdInput = `${pkg.name}
-${pkg.version}
-${mode}
-${sourceStamp}`;
-  const buildId = createHash3("sha256").update(buildIdInput).digest("hex").slice(0, 12);
-  return {
-    name: pkg.name,
-    version: pkg.version,
-    build_id: `${pkg.version}:${buildId}`,
-    built_at: sourceStamp || Date.now(),
-    source_stamp: sourceStamp || Date.now(),
-    mode
-  };
-}
-var cached4;
-function parseEnvNumber(raw4, fallback) {
-  const parsed = Number(raw4);
-  return Number.isFinite(parsed) ? parsed : fallback;
+for (const entry of builtinScenarioCatalog) {
+  Object.defineProperty(builtinScenarioPackagesTarget, entry.package_id, {
+    enumerable: true,
+    configurable: false,
+    get: () => loadBuiltinScenarioPackage(entry)
+  });
 }
-function currentRuntimeBuildInfo() {
-  if (cached4)
-    return cached4;
-  const defaultInfo = computeDefaultBuildInfo();
-  cached4 = {
-    name: process.env.AGENT_REMNOTE_NAME?.trim() || defaultInfo.name,
-    version: process.env.AGENT_REMNOTE_VERSION?.trim() || defaultInfo.version,
-    build_id: process.env.AGENT_REMNOTE_BUILD_ID?.trim() || defaultInfo.build_id,
-    built_at: parseEnvNumber(process.env.AGENT_REMNOTE_BUILD_AT, defaultInfo.built_at),
-    source_stamp: parseEnvNumber(process.env.AGENT_REMNOTE_SOURCE_STAMP, defaultInfo.source_stamp),
-    mode: process.env.AGENT_REMNOTE_BUILD_MODE === "src" || process.env.AGENT_REMNOTE_BUILD_MODE === "dist" || process.env.AGENT_REMNOTE_BUILD_MODE === "unknown" ? process.env.AGENT_REMNOTE_BUILD_MODE : defaultInfo.mode
-  };
-  return cached4;
+var builtinScenarioPackages = Object.freeze(builtinScenarioPackagesTarget);
+function getBuiltinScenarioPackage(id2) {
+  const entry = builtinScenarioCatalog.find((item) => item.package_id === id2);
+  if (!entry) {
+    throw new Error(`Unknown builtin scenario package: ${id2}`);
+  }
+  return loadBuiltinScenarioPackage(entry);
 }
-function runtimeVersionWarnings(params3) {
-  const warnings = [];
-  const compare2 = (label, other) => {
-    if (!other)
-      return;
-    if (other.build_id !== params3.current.build_id) {
-      warnings.push(`${label} build mismatch: current=${params3.current.build_id} live=${other.build_id}`);
-    }
-  };
-  compare2("daemon", params3.daemon);
-  compare2("plugin", params3.plugin);
-  compare2("api", params3.api);
-  return warnings;
+function getBuiltinScenarioPackageSourcePath(id2) {
+  const entry = builtinScenarioCatalog.find((item) => item.package_id === id2);
+  if (!entry) {
+    throw new Error(`Unknown builtin scenario source: ${id2}`);
+  }
+  return resolveBuiltinPackagePath(entry.package_path);
 }
 
 // src/lib/doctor/checks.ts
@@ -93021,7 +93991,7 @@ function collectDoctorChecks() {
       staleArtifacts.push({
         service: "daemon",
         pidFile: daemonPidFile,
-        stateFile: daemonPidInfo.state_file ?? path26.join(path26.dirname(daemonPidFile), "ws.state.json"),
+        stateFile: daemonPidInfo.state_file ?? path27.join(path27.dirname(daemonPidFile), "ws.state.json"),
         pid: daemonPidInfo.pid
       });
     }
@@ -93049,13 +94019,16 @@ function collectDoctorChecks() {
         pid: pluginPidInfo.pid
       });
     }
+    const pluginStateInfo = yield* pluginFiles.readStateFile(pluginPidInfo?.state_file ?? pluginFiles.defaultStateFile()).pipe(orElseSucceed2(() => {
+      return;
+    }));
     const current2 = currentRuntimeBuildInfo();
     const expectedPlugin = currentExpectedPluginBuildInfo();
     const mismatches = [
       daemonPidInfo?.build?.build_id && daemonPidInfo.build.build_id !== current2.build_id ? { service: "daemon", live: daemonPidInfo.build.build_id } : null,
       apiPidInfo?.build?.build_id && apiPidInfo.build.build_id !== current2.build_id ? { service: "api", live: apiPidInfo.build.build_id } : null,
       pluginPidInfo?.build?.build_id && pluginPidInfo.build.build_id !== current2.build_id ? { service: "plugin", live: pluginPidInfo.build.build_id } : null,
-      expectedPlugin && pluginPidInfo?.build?.build_id && pluginPidInfo.build.build_id !== expectedPlugin.build_id ? { service: "plugin-artifact", live: pluginPidInfo.build.build_id, expected: expectedPlugin.build_id } : null
+      expectedPlugin && pluginStateInfo?.plugin_build?.build_id && pluginStateInfo.plugin_build.build_id !== expectedPlugin.build_id ? { service: "plugin-artifact", live: pluginStateInfo.plugin_build.build_id, expected: expectedPlugin.build_id } : null
     ].filter(Boolean);
     const configPreview = yield* userConfig.previewRepair().pipe(either3);
     const configChanged = configPreview._tag === "Right" ? configPreview.right.changed : false;
@@ -93069,269 +94042,76 @@ function collectDoctorChecks() {
         return { ok: true, details: undefined };
       } catch (error4) {
         return { ok: false, details: { error: String(error4?.message || error4) } };
-      }
-    });
-    const pluginArtifactsCheck = yield* sync3(() => {
-      try {
-        return { ok: true, details: { distPath: resolvePluginDistPath(), zipPath: resolvePluginZipPath() } };
-      } catch (error4) {
-        return { ok: false, details: { error: String(error4?.message || error4) } };
-      }
-    });
-    const pidWritable = yield* fsAccess.canWritePath(daemonPidFile);
-    const logWritable = yield* fsAccess.canWritePath(daemonFiles.defaultLogFile());
-    const storeWritable = yield* fsAccess.checkWritableFile(cfg.storeDb);
-    const pathOk = pidWritable && logWritable && storeWritable.ok;
-    return [
-      {
-        id: "runtime.stale_pid_or_state",
-        ok: staleArtifacts.length === 0,
-        severity: staleArtifacts.length === 0 ? "info" : "warning",
-        summary: staleArtifacts.length === 0 ? "No stale runtime pid/state artifacts" : `Found ${staleArtifacts.length} stale runtime artifact set(s)`,
-        details: staleArtifacts,
-        repairable: staleArtifacts.length > 0
-      },
-      {
-        id: "runtime.version_mismatch",
-        ok: mismatches.length === 0,
-        severity: mismatches.length === 0 ? "info" : "warning",
-        summary: mismatches.length === 0 ? "No runtime build mismatch detected" : `Found ${mismatches.length} runtime build mismatch(es)`,
-        details: mismatches,
-        repairable: mismatches.length > 0
-      },
-      {
-        id: "config.migration_needed",
-        ok: configValid && !configChanged,
-        severity: !configValid ? "error" : configChanged ? "warning" : "info",
-        summary: !configValid ? "User config is invalid or conflicting" : configChanged ? "User config can be canonicalized" : "User config already canonical",
-        details: configDetails,
-        repairable: configRepairable
-      },
-      {
-        id: "package.builtin_scenarios_broken",
-        ok: packageCheck.ok,
-        severity: packageCheck.ok ? "info" : "error",
-        summary: packageCheck.ok ? "Builtin scenarios are loadable" : "Builtin scenario package loading failed",
-        details: packageCheck.details,
-        repairable: !packageCheck.ok
-      },
-      {
-        id: "package.plugin_artifacts_unavailable",
-        ok: pluginArtifactsCheck.ok,
-        severity: pluginArtifactsCheck.ok ? "info" : "error",
-        summary: pluginArtifactsCheck.ok ? "Plugin artifacts are available" : "Plugin artifacts are unavailable",
-        details: pluginArtifactsCheck.details,
-        repairable: false
-      },
-      {
-        id: "env.path_or_permission_problem",
-        ok: pathOk,
-        severity: pathOk ? "info" : "error",
-        summary: pathOk ? "Required writable paths are available" : "One or more required paths are not writable",
-        details: {
-          daemon_pid_file: daemonPidFile,
-          daemon_log_file: daemonFiles.defaultLogFile(),
-          pid_writable: pidWritable,
-          log_writable: logWritable,
-          store_db: cfg.storeDb,
-          store_writable: storeWritable
-        },
-        repairable: false
-      }
-    ];
-  });
-}
-
-// src/commands/ws/_shared.ts
-import path27 from "node:path";
-var WS_HEALTH_TIMEOUT_MS = 2000;
-var WS_START_WAIT_DEFAULT_MS = 15000;
-var WS_STOP_WAIT_DEFAULT_MS = 5000;
-function supervisorCommandLine(params3) {
-  const command = process.argv[0];
-  const script = process.argv[1];
-  if (!command || !script) {
-    throw new CliError({
-      code: "INTERNAL",
-      message: "Unable to determine the current executable entrypoint (process.argv is incomplete)",
-      exitCode: 1,
-      details: { argv: process.argv }
-    });
-  }
-  const execArgv = Array.isArray(process.execArgv) ? process.execArgv : [];
-  return {
-    command,
-    args: [
-      ...execArgv,
-      script,
-      "--daemon-url",
-      params3.wsUrl,
-      "--store-db",
-      params3.storeDb,
-      "daemon",
-      "supervisor",
-      "--pid-file",
-      params3.pidFile,
-      "--log-file",
-      params3.logFile,
-      "--state-file",
-      params3.stateFile
-    ]
-  };
-}
-function toPidFileValue(params3) {
-  return {
-    pid: params3.pid,
-    build: currentRuntimeBuildInfo(),
-    started_at: params3.startedAt,
-    ws_url: params3.wsUrl,
-    log_file: params3.logFile,
-    cmd: params3.cmd,
-    ws_bridge_state_file: params3.wsBridgeStateFile,
-    status_line_file: params3.statusLineFile,
-    status_line_json_file: params3.statusLineJsonFile
-  };
-}
-function waitForHealth(url2, waitMs) {
-  return gen2(function* () {
-    if (!Number.isFinite(waitMs) || waitMs < 0) {
-      return yield* fail8(new CliError({
-        code: "INVALID_ARGS",
-        message: "--wait must be a non-negative integer (ms)",
-        exitCode: 2,
-        details: { wait_ms: waitMs }
-      }));
-    }
-    if (waitMs === 0)
-      return;
-    const ws = yield* WsClient;
-    const deadline = Date.now() + waitMs;
-    while (Date.now() < deadline) {
-      const remaining = Math.max(0, deadline - Date.now());
-      const res = yield* ws.health({ url: url2, timeoutMs: Math.min(WS_HEALTH_TIMEOUT_MS, Math.max(1, remaining)) }).pipe(either3);
-      if (isRight2(res))
-        return;
-      yield* sleep4(millis(300));
-    }
-    return yield* fail8(new CliError({
-      code: "WS_TIMEOUT",
-      message: `Timed out waiting for WS to become available (${waitMs}ms)`,
-      exitCode: 1,
-      details: { url: url2, wait_ms: waitMs },
-      hint: ["agent-remnote daemon status", "agent-remnote daemon logs", "agent-remnote daemon health --json"]
-    }));
-  });
-}
-function toInitialSupervisorState(now2) {
-  return {
-    status: "running",
-    restart_count: 0,
-    restart_window_started_at: now2,
-    backoff_until: null,
-    last_exit: null,
-    failed_reason: null
-  };
-}
-function defaultStateFilePathFromPidFile(pidFilePath) {
-  return path27.join(path27.dirname(pidFilePath), "ws.state.json");
-}
-function startWsSupervisor(params3) {
-  return gen2(function* () {
-    const cfg = yield* AppConfig;
-    const daemonFiles = yield* DaemonFiles;
-    const supervisorState = yield* SupervisorState;
-    const proc = yield* Process;
-    const ws = yield* WsClient;
-    const pidFilePath = resolveUserFilePath(params3.pidFile ?? daemonFiles.defaultPidFile());
-    const logFilePath = resolveUserFilePath(params3.logFile ?? daemonFiles.defaultLogFile());
-    const stateFilePath = defaultStateFilePathFromPidFile(pidFilePath);
-    const existingPidFile = yield* daemonFiles.readPidFile(pidFilePath);
-    if (existingPidFile) {
-      const alive = yield* proc.isPidRunning(existingPidFile.pid);
-      if (!alive) {
-        yield* daemonFiles.deletePidFile(pidFilePath);
-        yield* supervisorState.deleteStateFile(stateFilePath);
-      } else {
-        yield* requireTrustedPidRecord({ record: existingPidFile, pidFilePath });
-        return {
-          started: false,
-          pid: existingPidFile.pid,
-          pid_file: pidFilePath,
-          log_file: existingPidFile.log_file ?? logFilePath
-        };
-      }
-    }
-    const pre = yield* ws.health({ url: cfg.wsUrl, timeoutMs: WS_HEALTH_TIMEOUT_MS }).pipe(either3);
-    if (isRight2(pre)) {
-      return { started: false, pid_file: pidFilePath, log_file: logFilePath };
-    }
-    const cmd = yield* try_3({
-      try: () => supervisorCommandLine({
-        wsUrl: cfg.wsUrl,
-        storeDb: cfg.storeDb,
-        pidFile: pidFilePath,
-        logFile: logFilePath,
-        stateFile: stateFilePath
-      }),
-      catch: (e) => isCliError(e) ? e : new CliError({
-        code: "INTERNAL",
-        message: "Failed to start supervisor",
-        exitCode: 1,
-        details: { error: String(e?.message || e) }
-      })
+      }
     });
-    const pid = yield* proc.spawnDetached({ command: cmd.command, args: cmd.args, logFile: logFilePath });
-    const now2 = Date.now();
-    yield* daemonFiles.writePidFile(pidFilePath, {
-      ...toPidFileValue({
-        pid,
-        startedAt: now2,
-        wsUrl: cfg.wsUrl,
-        logFile: logFilePath,
-        cmd: [cmd.command, ...cmd.args],
-        wsBridgeStateFile: cfg.wsStateFile.path,
-        statusLineFile: cfg.statusLineFile,
-        statusLineJsonFile: cfg.statusLineJsonFile
-      }),
-      mode: "supervisor",
-      child_pid: null,
-      state_file: stateFilePath
+    const pluginArtifactsCheck = yield* sync3(() => {
+      try {
+        return { ok: true, details: { distPath: resolvePluginDistPath(), zipPath: resolvePluginZipPath() } };
+      } catch (error4) {
+        return { ok: false, details: { error: String(error4?.message || error4) } };
+      }
     });
-    yield* supervisorState.writeStateFile(stateFilePath, toInitialSupervisorState(now2));
-    yield* waitForHealth(cfg.wsUrl, params3.waitMs);
-    return { started: true, pid, pid_file: pidFilePath, log_file: logFilePath };
-  });
-}
-function ensureWsSupervisor(params3) {
-  return gen2(function* () {
-    const cfg = yield* AppConfig;
-    const ws = yield* WsClient;
-    const pre = yield* ws.health({ url: cfg.wsUrl, timeoutMs: WS_HEALTH_TIMEOUT_MS }).pipe(either3);
-    if (isRight2(pre)) {
-      const daemonFiles = yield* DaemonFiles;
-      const proc = yield* Process;
-      const pidFilePath = resolveUserFilePath(params3.pidFile ?? daemonFiles.defaultPidFile());
-      const logFilePath = resolveUserFilePath(params3.logFile ?? daemonFiles.defaultLogFile());
-      const existingPidFile = yield* daemonFiles.readPidFile(pidFilePath);
-      if (existingPidFile) {
-        const alive = yield* proc.isPidRunning(existingPidFile.pid);
-        if (alive) {
-          yield* requireTrustedPidRecord({ record: existingPidFile, pidFilePath });
-          return {
-            started: false,
-            pid: existingPidFile.pid,
-            pid_file: pidFilePath,
-            log_file: existingPidFile.log_file ?? logFilePath
-          };
-        }
+    const pidWritable = yield* fsAccess.canWritePath(daemonPidFile);
+    const logWritable = yield* fsAccess.canWritePath(daemonFiles.defaultLogFile());
+    const storeWritable = yield* fsAccess.checkWritableFile(cfg.storeDb);
+    const pathOk = pidWritable && logWritable && storeWritable.ok;
+    return [
+      {
+        id: "runtime.stale_pid_or_state",
+        ok: staleArtifacts.length === 0,
+        severity: staleArtifacts.length === 0 ? "info" : "warning",
+        summary: staleArtifacts.length === 0 ? "No stale runtime pid/state artifacts" : `Found ${staleArtifacts.length} stale runtime artifact set(s)`,
+        details: staleArtifacts,
+        repairable: staleArtifacts.length > 0
+      },
+      {
+        id: "runtime.version_mismatch",
+        ok: mismatches.length === 0,
+        severity: mismatches.length === 0 ? "info" : "warning",
+        summary: mismatches.length === 0 ? "No runtime build mismatch detected" : `Found ${mismatches.length} runtime build mismatch(es)`,
+        details: mismatches,
+        repairable: mismatches.length > 0
+      },
+      {
+        id: "config.migration_needed",
+        ok: configValid && !configChanged,
+        severity: !configValid ? "error" : configChanged ? "warning" : "info",
+        summary: !configValid ? "User config is invalid or conflicting" : configChanged ? "User config can be canonicalized" : "User config already canonical",
+        details: configDetails,
+        repairable: configRepairable
+      },
+      {
+        id: "package.builtin_scenarios_broken",
+        ok: packageCheck.ok,
+        severity: packageCheck.ok ? "info" : "error",
+        summary: packageCheck.ok ? "Builtin scenarios are loadable" : "Builtin scenario package loading failed",
+        details: packageCheck.details,
+        repairable: !packageCheck.ok
+      },
+      {
+        id: "package.plugin_artifacts_unavailable",
+        ok: pluginArtifactsCheck.ok,
+        severity: pluginArtifactsCheck.ok ? "info" : "error",
+        summary: pluginArtifactsCheck.ok ? "Plugin artifacts are available" : "Plugin artifacts are unavailable",
+        details: pluginArtifactsCheck.details,
+        repairable: false
+      },
+      {
+        id: "env.path_or_permission_problem",
+        ok: pathOk,
+        severity: pathOk ? "info" : "error",
+        summary: pathOk ? "Required writable paths are available" : "One or more required paths are not writable",
+        details: {
+          daemon_pid_file: daemonPidFile,
+          daemon_log_file: daemonFiles.defaultLogFile(),
+          pid_writable: pidWritable,
+          log_writable: logWritable,
+          store_db: cfg.storeDb,
+          store_writable: storeWritable
+        },
+        repairable: false
       }
-      return {
-        started: false,
-        pid_file: pidFilePath,
-        log_file: logFilePath
-      };
-    }
-    return yield* startWsSupervisor(params3);
+    ];
   });
 }
 
@@ -95429,7 +96209,7 @@ var baseBackoffMs = integer7("backoff-ms").pipe(withDefault5(500));
 var maxBackoffMs = integer7("max-backoff-ms").pipe(withDefault5(1e4));
 var logMaxBytes = integer7("log-max-bytes").pipe(withDefault5(0));
 var logKeep = integer7("log-keep").pipe(withDefault5(5));
-function childCommandLine(params3) {
+function childCommandLine3(params3) {
   const command = process.argv[0];
   const script = process.argv[1];
   if (!command || !script) {
@@ -95454,7 +96234,7 @@ var wsSupervisorCommand = exports_Command.make("supervisor", { pidFile: pidFile7
   const logFilePath = resolveUserFilePath(logFile5 ?? daemonFiles.defaultLogFile());
   const stateFilePath = resolveUserFilePath(stateFile3 ?? supervisorState.defaultStateFile());
   const childCmd = yield* try_3({
-    try: () => childCommandLine({ wsUrl: cfg.wsUrl, storeDb: cfg.storeDb }),
+    try: () => childCommandLine3({ wsUrl: cfg.wsUrl, storeDb: cfg.storeDb }),
     catch: (e) => isCliError(e) ? e : new CliError({
       code: "INTERNAL",
       message: "Failed to build child command line",
@@ -95770,238 +96550,11 @@ function waitForTxn(params3) {
           ]
         }));
       }
-      yield* sleep4(millis(resolvedPollMs));
-    }
-  });
-}
-
-// src/lib/apiUrls.ts
-function normalizeApiBasePath2(basePath) {
-  const trimmed2 = basePath.trim();
-  if (!trimmed2)
-    return "/v1";
-  const normalized = trimmed2.startsWith("/") ? trimmed2 : `/${trimmed2}`;
-  const withoutTrailing = normalized.replace(/\/+$/, "");
-  return withoutTrailing && withoutTrailing !== "/" ? withoutTrailing : "/";
-}
-function normalizeBaseUrl(baseUrl) {
-  return baseUrl.trim().replace(/\/+$/, "");
-}
-function resolveBasePrefix(baseUrl, fallbackBasePath) {
-  const parsed = new URL(normalizeBaseUrl(baseUrl));
-  const pathname = normalizeApiBasePath2(parsed.pathname);
-  if (pathname && pathname !== "/")
-    return normalizeApiBasePath2(pathname);
-  return normalizeApiBasePath2(fallbackBasePath);
-}
-function normalizeRoutePath(routePath) {
-  const trimmed2 = routePath.trim();
-  if (!trimmed2)
-    return "";
-  return `/${trimmed2.replace(/^\/+/, "")}`;
-}
-function buildApiBaseUrl(baseUrl, fallbackBasePath = "/v1") {
-  const parsed = new URL(normalizeBaseUrl(baseUrl));
-  const prefix2 = resolveBasePrefix(baseUrl, fallbackBasePath);
-  return prefix2 === "/" ? parsed.origin : `${parsed.origin}${prefix2}`;
-}
-function apiLocalBaseUrl(port3, basePath = "/v1") {
-  return buildApiBaseUrl(`http://127.0.0.1:${port3}`, basePath);
-}
-function apiContainerBaseUrl(port3, basePath = "/v1") {
-  return buildApiBaseUrl(`http://host.docker.internal:${port3}`, basePath);
-}
-function joinApiUrl(baseUrl, routePath, fallbackBasePath = "/v1") {
-  return `${buildApiBaseUrl(baseUrl, fallbackBasePath)}${normalizeRoutePath(routePath)}`;
-}
-
-// src/services/HostApiClient.ts
-function normalizeBaseUrl2(baseUrl) {
-  return baseUrl.trim().replace(/\/+$/, "");
-}
-function apiTimeoutError(params3) {
-  return new CliError({
-    code: "API_TIMEOUT",
-    message: `API timeout after ${params3.timeoutMs}ms`,
-    exitCode: 1,
-    details: { base_url: params3.baseUrl, path: params3.path, timeout_ms: params3.timeoutMs }
-  });
-}
-function apiUnavailableError(params3) {
-  return new CliError({
-    code: "API_UNAVAILABLE",
-    message: String(params3.error?.message || params3.error || "API request failed"),
-    exitCode: 1,
-    details: { base_url: params3.baseUrl, path: params3.path }
-  });
-}
-function exitCodeFromRemoteCode(code2) {
-  return code2 === "INVALID_ARGS" || code2 === "INVALID_PAYLOAD" || code2 === "PAYLOAD_TOO_LARGE" ? 2 : 1;
-}
-function parseEnvelope(raw4) {
-  if (!raw4 || typeof raw4 !== "object") {
-    return { ok: false, error: { code: "INTERNAL", message: "Invalid API response envelope" } };
-  }
-  return raw4;
-}
-function buildQuery(params3) {
-  const sp = new URLSearchParams;
-  for (const [key, value8] of Object.entries(params3)) {
-    if (value8 === undefined || value8 === null)
-      continue;
-    if (typeof value8 === "string") {
-      if (!value8.trim())
-        continue;
-      sp.set(key, value8);
-      continue;
-    }
-    if (typeof value8 === "number" || typeof value8 === "boolean") {
-      sp.set(key, String(value8));
-    }
-  }
-  const query = sp.toString();
-  return query ? `?${query}` : "";
-}
-function requestJson(params3) {
-  const timeoutMs = Math.max(1, params3.timeoutMs ?? 15000);
-  const baseUrl = normalizeBaseUrl2(params3.baseUrl);
-  const url2 = joinApiUrl(baseUrl, params3.path, params3.basePath);
-  return async((resume2) => {
-    const controller = new AbortController;
-    const timer2 = setTimeout(() => controller.abort(), timeoutMs);
-    fetch(url2, {
-      method: params3.method,
-      headers: params3.method === "POST" ? { "content-type": "application/json" } : undefined,
-      body: params3.body === undefined ? undefined : JSON.stringify(params3.body),
-      signal: controller.signal
-    }).then(async (response) => {
-      clearTimeout(timer2);
-      let parsed;
-      try {
-        parsed = parseEnvelope(await response.json());
-      } catch (error4) {
-        resume2(fail8(new CliError({
-          code: "API_UNAVAILABLE",
-          message: "API returned a non-JSON response",
-          exitCode: 1,
-          details: { url: url2, status: response.status, error: String(error4?.message || error4) }
-        })));
-        return;
-      }
-      if (parsed.ok === true) {
-        resume2(succeed8(parsed.data));
-        return;
-      }
-      const code2 = typeof parsed.error?.code === "string" ? parsed.error.code : "INTERNAL";
-      const message2 = typeof parsed.error?.message === "string" ? parsed.error.message : "API request failed";
-      const hint = Array.isArray(parsed.hint) ? parsed.hint.map(String) : undefined;
-      resume2(fail8(new CliError({
-        code: code2,
-        message: message2,
-        exitCode: exitCodeFromRemoteCode(code2),
-        details: parsed.error?.details,
-        hint
-      })));
-    }).catch((error4) => {
-      clearTimeout(timer2);
-      if (error4?.name === "AbortError") {
-        resume2(fail8(apiTimeoutError({ baseUrl, path: params3.path, timeoutMs })));
-        return;
-      }
-      resume2(fail8(apiUnavailableError({ baseUrl, path: params3.path, error: error4 })));
-    });
-    return sync3(() => {
-      clearTimeout(timer2);
-      controller.abort();
-    });
+      yield* sleep4(millis(resolvedPollMs));
+    }
   });
 }
 
-class HostApiClient extends Tag2("HostApiClient")() {
-}
-var HostApiClientLive = effect(HostApiClient, gen2(function* () {
-  const cfg = yield* AppConfig;
-  const basePath = cfg.apiBasePath ?? "/v1";
-  const request = (params3) => requestJson({ ...params3, basePath });
-  return {
-    resolveRefValue: ({ baseUrl, body, timeoutMs }) => request({ baseUrl, path: "/ref/resolve", method: "POST", body, timeoutMs }),
-    resolvePlacement: ({ baseUrl, body, timeoutMs }) => request({ baseUrl, path: "/placement/resolve", method: "POST", body, timeoutMs }),
-    resolveStableSiblingRange: ({ baseUrl, body, timeoutMs }) => request({ baseUrl, path: "/selection/stable-sibling-range", method: "POST", body, timeoutMs }),
-    health: ({ baseUrl, timeoutMs }) => request({ baseUrl, path: "/health", method: "GET", timeoutMs }),
-    status: ({ baseUrl, timeoutMs }) => request({ baseUrl, path: "/status", method: "GET", timeoutMs }),
-    uiContextSnapshot: ({ baseUrl, stateFile: stateFile3, staleMs: staleMs2, timeoutMs }) => request({
-      baseUrl,
-      path: `/plugin/ui-context/snapshot${buildQuery({ stateFile: stateFile3, staleMs: staleMs2 })}`,
-      method: "GET",
-      timeoutMs
-    }),
-    uiContextPage: ({ baseUrl, stateFile: stateFile3, staleMs: staleMs2, timeoutMs }) => request({
-      baseUrl,
-      path: `/plugin/ui-context/page${buildQuery({ stateFile: stateFile3, staleMs: staleMs2 })}`,
-      method: "GET",
-      timeoutMs
-    }),
-    uiContextFocusedRem: ({ baseUrl, stateFile: stateFile3, staleMs: staleMs2, timeoutMs }) => request({
-      baseUrl,
-      path: `/plugin/ui-context/focused-rem${buildQuery({ stateFile: stateFile3, staleMs: staleMs2 })}`,
-      method: "GET",
-      timeoutMs
-    }),
-    uiContextDescribe: ({ baseUrl, stateFile: stateFile3, staleMs: staleMs2, selectionLimit, timeoutMs }) => request({
-      baseUrl,
-      path: `/plugin/ui-context/describe${buildQuery({ stateFile: stateFile3, staleMs: staleMs2, selectionLimit })}`,
-      method: "GET",
-      timeoutMs
-    }),
-    selectionSnapshot: ({ baseUrl, stateFile: stateFile3, staleMs: staleMs2, timeoutMs }) => request({
-      baseUrl,
-      path: `/plugin/selection/snapshot${buildQuery({ stateFile: stateFile3, staleMs: staleMs2 })}`,
-      method: "GET",
-      timeoutMs
-    }),
-    selectionRoots: ({ baseUrl, stateFile: stateFile3, staleMs: staleMs2, timeoutMs }) => request({
-      baseUrl,
-      path: `/plugin/selection/roots${buildQuery({ stateFile: stateFile3, staleMs: staleMs2 })}`,
-      method: "GET",
-      timeoutMs
-    }),
-    selectionCurrent: ({ baseUrl, stateFile: stateFile3, staleMs: staleMs2, timeoutMs }) => request({
-      baseUrl,
-      path: `/plugin/selection/current${buildQuery({ stateFile: stateFile3, staleMs: staleMs2 })}`,
-      method: "GET",
-      timeoutMs
-    }),
-    pluginCurrent: ({ baseUrl, stateFile: stateFile3, staleMs: staleMs2, selectionLimit, timeoutMs }) => request({
-      baseUrl,
-      path: `/plugin/current${buildQuery({ stateFile: stateFile3, staleMs: staleMs2, selectionLimit })}`,
-      method: "GET",
-      timeoutMs
-    }),
-    selectionOutline: ({ baseUrl, body, timeoutMs }) => request({ baseUrl, path: "/plugin/selection/outline", method: "POST", body, timeoutMs }),
-    uiContext: ({ baseUrl, timeoutMs }) => request({ baseUrl, path: "/ui-context", method: "GET", timeoutMs }),
-    selection: ({ baseUrl, timeoutMs }) => request({ baseUrl, path: "/selection", method: "GET", timeoutMs }),
-    searchDb: ({ baseUrl, ...body }) => request({ baseUrl, path: "/search/db", method: "POST", body }),
-    searchPlugin: ({ baseUrl, ...body }) => request({ baseUrl, path: "/search/plugin", method: "POST", body }),
-    writeApply: ({ baseUrl, body, timeoutMs }) => request({ baseUrl, path: "/write/apply", method: "POST", body, timeoutMs }),
-    readOutline: ({ baseUrl, body, timeoutMs }) => request({ baseUrl, path: "/read/outline", method: "POST", body, timeoutMs }),
-    readPageId: ({ baseUrl, body, timeoutMs }) => request({ baseUrl, path: "/read/page-id", method: "POST", body, timeoutMs }),
-    resolveRef: ({ baseUrl, body, timeoutMs }) => request({ baseUrl, path: "/read/resolve-ref", method: "POST", body, timeoutMs }),
-    byReference: ({ baseUrl, body, timeoutMs }) => request({ baseUrl, path: "/read/by-reference", method: "POST", body, timeoutMs }),
-    references: ({ baseUrl, body, timeoutMs }) => request({ baseUrl, path: "/read/references", method: "POST", body, timeoutMs }),
-    resolveQueryPowerup: ({ baseUrl, powerup, timeoutMs }) => request({ baseUrl, path: "/internal/query/resolve-powerup", method: "POST", body: { powerup }, timeoutMs }),
-    query: ({ baseUrl, body, timeoutMs }) => request({ baseUrl, path: "/read/query", method: "POST", body, timeoutMs }),
-    dailyRemId: ({ baseUrl, date: date6, offsetDays, timeoutMs }) => request({
-      baseUrl,
-      path: `/daily/rem-id${buildQuery({ date: date6, offsetDays })}`,
-      method: "GET",
-      timeoutMs
-    }),
-    queueWait: ({ baseUrl, txnId, timeoutMs, pollMs }) => request({ baseUrl, path: "/queue/wait", method: "POST", body: { txnId, timeoutMs, pollMs } }),
-    queueTxn: ({ baseUrl, txnId, timeoutMs }) => request({ baseUrl, path: `/queue/txns/${encodeURIComponent(txnId)}`, method: "GET", timeoutMs }),
-    triggerSync: ({ baseUrl, timeoutMs }) => request({ baseUrl, path: "/actions/trigger-sync", method: "POST", timeoutMs })
-  };
-}));
-
 // src/lib/workspaceResolver.ts
 import fs19 from "node:fs";
 
@@ -101420,232 +101973,46 @@ var applyCommand = exports_Command.make("apply", {
   const resolvedIdempotencyKey = idempotencyKey3 ?? compiled.idempotencyKey;
   if (dryRun) {
     yield* writeSuccess({
-      data: {
-        dry_run: true,
-        kind: compiled.kind,
-        ops: compiled.ops,
-        alias_map: compiled.aliasMap,
-        meta: metaValue ? payloadSvc.normalizeKeys(metaValue) : undefined
-      },
-      md: `- dry_run: true
-- kind: ${compiled.kind}
-- ops: ${compiled.ops.length}
-`
-    });
-    return;
-  }
-  yield* validateOptionMutationOps({ scopeLabel: "generic", ops: compiled.ops });
-  const data = yield* invokeWave1Capability("write.apply", {
-    body: {
-      ...expanded,
-      priority: resolvedPriority,
-      clientId: resolvedClientId,
-      idempotencyKey: resolvedIdempotencyKey,
-      meta: metaValue,
-      notify: notify3 ?? compiled.notify ?? true,
-      ensureDaemon: ensureDaemon4 ?? compiled.ensureDaemon ?? true
-    },
-    wait: wait3,
-    timeoutMs: timeoutMs3,
-    pollMs: pollMs3
-  });
-  const out = compiled.kind === "actions" ? { ...data, alias_map: data?.alias_map ?? compiled.aliasMap } : data;
-  yield* writeSuccess({
-    data: out,
-    ids: [data.txn_id, ...data.op_ids],
-    md: `- txn_id: ${data.txn_id}
-- op_ids: ${data.op_ids.length}
-- notified: ${data.notified}
-- sent: ${data.sent ?? ""}
-`
-  });
-}).pipe(catchAll2(writeFailure)));
-
-// src/commands/api/_shared.ts
-var API_HEALTH_TIMEOUT_MS = 2000;
-var API_START_WAIT_DEFAULT_MS = 15000;
-var API_STOP_WAIT_DEFAULT_MS = 5000;
-function childCommandLine2(params3) {
-  const command = process.argv[0];
-  const script = process.argv[1];
-  if (!command || !script) {
-    throw new CliError({
-      code: "INTERNAL",
-      message: "Unable to determine the current executable entrypoint (process.argv is incomplete)",
-      exitCode: 1,
-      details: { argv: process.argv }
-    });
-  }
-  const execArgv = Array.isArray(process.execArgv) ? process.execArgv : [];
-  const args2 = [...execArgv, script, "--daemon-url", params3.wsUrl, "--store-db", params3.storeDb];
-  if (params3.remnoteDb)
-    args2.push("--remnote-db", params3.remnoteDb);
-  args2.push("--api-base-path", params3.basePath);
-  args2.push("api", "serve", "--host", params3.host, "--port", String(params3.port), "--state-file", params3.stateFile);
-  return { command, args: args2 };
-}
-function toPidFileValue2(params3) {
-  return {
-    pid: params3.pid,
-    build: currentRuntimeBuildInfo(),
-    started_at: params3.startedAt,
-    host: params3.host,
-    port: params3.port,
-    base_path: params3.basePath,
-    log_file: params3.logFile,
-    state_file: params3.stateFile,
-    cmd: params3.cmd
-  };
-}
-function waitForApiHealth(baseUrl, waitMs) {
-  return gen2(function* () {
-    if (!Number.isFinite(waitMs) || waitMs < 0) {
-      return yield* fail8(new CliError({
-        code: "INVALID_ARGS",
-        message: "--wait must be a non-negative integer (ms)",
-        exitCode: 2,
-        details: { wait_ms: waitMs }
-      }));
-    }
-    if (waitMs === 0)
-      return;
-    const api = yield* HostApiClient;
-    const deadline = Date.now() + waitMs;
-    while (Date.now() < deadline) {
-      const remaining = Math.max(0, deadline - Date.now());
-      const res = yield* api.health({ baseUrl, timeoutMs: Math.min(API_HEALTH_TIMEOUT_MS, Math.max(1, remaining)) }).pipe(either3);
-      if (isRight2(res))
-        return;
-      yield* sleep4(millis(300));
-    }
-    return yield* fail8(new CliError({
-      code: "API_TIMEOUT",
-      message: `Timed out waiting for host API to become available (${waitMs}ms)`,
-      exitCode: 1,
-      details: { base_url: baseUrl, wait_ms: waitMs },
-      hint: ["agent-remnote api status --json", "agent-remnote api logs", "agent-remnote stack status --json"]
-    }));
-  });
-}
-function startApiDaemon(params3) {
-  return gen2(function* () {
-    const cfg = yield* AppConfig;
-    const api = yield* HostApiClient;
-    const apiFiles = yield* ApiDaemonFiles;
-    const proc = yield* Process;
-    const host = params3.host ?? cfg.apiHost ?? "0.0.0.0";
-    const port3 = params3.port ?? cfg.apiPort ?? 3000;
-    const basePath2 = cfg.apiBasePath ?? "/v1";
-    const pidFilePath = resolveUserFilePath(params3.pidFile ?? apiFiles.defaultPidFile());
-    const logFilePath = resolveUserFilePath(params3.logFile ?? apiFiles.defaultLogFile());
-    const stateFilePath = resolveUserFilePath(params3.stateFile ?? apiFiles.defaultStateFile());
-    const localBaseUrl = apiLocalBaseUrl(port3, basePath2);
-    const existing = yield* apiFiles.readPidFile(pidFilePath);
-    if (existing) {
-      const alive = yield* proc.isPidRunning(existing.pid);
-      if (!alive) {
-        yield* apiFiles.deletePidFile(pidFilePath);
-      } else {
-        yield* requireTrustedPidRecord({ record: existing, pidFilePath });
-        return {
-          started: false,
-          pid: existing.pid,
-          pid_file: pidFilePath,
-          log_file: logFilePath,
-          state_file: stateFilePath,
-          base_url: localBaseUrl
-        };
-      }
-    }
-    const pre = yield* api.health({ baseUrl: localBaseUrl, timeoutMs: API_HEALTH_TIMEOUT_MS }).pipe(either3);
-    if (isRight2(pre)) {
-      return {
-        started: false,
-        pid_file: pidFilePath,
-        log_file: logFilePath,
-        state_file: stateFilePath,
-        base_url: localBaseUrl
-      };
-    }
-    const cmd = yield* try_3({
-      try: () => childCommandLine2({
-        wsUrl: cfg.wsUrl,
-        storeDb: cfg.storeDb,
-        remnoteDb: cfg.remnoteDb,
-        host,
-        port: port3,
-        basePath: basePath2,
-        stateFile: stateFilePath
-      }),
-      catch: (e) => isCliError(e) ? e : new CliError({
-        code: "INTERNAL",
-        message: "Failed to start host api",
-        exitCode: 1,
-        details: { error: String(e?.message || e) }
-      })
-    });
-    const pid = yield* proc.spawnDetached({ command: cmd.command, args: cmd.args, logFile: logFilePath });
-    yield* apiFiles.writePidFile(pidFilePath, toPidFileValue2({
-      pid,
-      startedAt: Date.now(),
-      host,
-      port: port3,
-      basePath: basePath2,
-      logFile: logFilePath,
-      stateFile: stateFilePath,
-      cmd: [cmd.command, ...cmd.args]
-    }));
-    yield* waitForApiHealth(localBaseUrl, params3.waitMs);
-    return {
-      started: true,
-      pid,
-      pid_file: pidFilePath,
-      log_file: logFilePath,
-      state_file: stateFilePath,
-      base_url: localBaseUrl
-    };
+      data: {
+        dry_run: true,
+        kind: compiled.kind,
+        ops: compiled.ops,
+        alias_map: compiled.aliasMap,
+        meta: metaValue ? payloadSvc.normalizeKeys(metaValue) : undefined
+      },
+      md: `- dry_run: true
+- kind: ${compiled.kind}
+- ops: ${compiled.ops.length}
+`
+    });
+    return;
+  }
+  yield* validateOptionMutationOps({ scopeLabel: "generic", ops: compiled.ops });
+  const data = yield* invokeWave1Capability("write.apply", {
+    body: {
+      ...expanded,
+      priority: resolvedPriority,
+      clientId: resolvedClientId,
+      idempotencyKey: resolvedIdempotencyKey,
+      meta: metaValue,
+      notify: notify3 ?? compiled.notify ?? true,
+      ensureDaemon: ensureDaemon4 ?? compiled.ensureDaemon ?? true
+    },
+    wait: wait3,
+    timeoutMs: timeoutMs3,
+    pollMs: pollMs3
   });
-}
-function ensureApiDaemon(params3) {
-  return gen2(function* () {
-    const cfg = yield* AppConfig;
-    const api = yield* HostApiClient;
-    const apiFiles = yield* ApiDaemonFiles;
-    const proc = yield* Process;
-    const port3 = params3.port ?? cfg.apiPort ?? 3000;
-    const basePath2 = cfg.apiBasePath ?? "/v1";
-    const pidFilePath = resolveUserFilePath(params3.pidFile ?? apiFiles.defaultPidFile());
-    const logFilePath = resolveUserFilePath(params3.logFile ?? apiFiles.defaultLogFile());
-    const stateFilePath = resolveUserFilePath(params3.stateFile ?? apiFiles.defaultStateFile());
-    const localBaseUrl = apiLocalBaseUrl(port3, basePath2);
-    const pre = yield* api.health({ baseUrl: localBaseUrl, timeoutMs: API_HEALTH_TIMEOUT_MS }).pipe(either3);
-    if (isRight2(pre)) {
-      const existing = yield* apiFiles.readPidFile(pidFilePath);
-      if (existing) {
-        const alive = yield* proc.isPidRunning(existing.pid);
-        if (alive) {
-          yield* requireTrustedPidRecord({ record: existing, pidFilePath });
-          return {
-            started: false,
-            pid: existing.pid,
-            pid_file: pidFilePath,
-            log_file: existing.log_file ?? logFilePath,
-            state_file: existing.state_file ?? stateFilePath,
-            base_url: localBaseUrl
-          };
-        }
-      }
-      return {
-        started: false,
-        pid_file: pidFilePath,
-        log_file: logFilePath,
-        state_file: stateFilePath,
-        base_url: localBaseUrl
-      };
-    }
-    return yield* startApiDaemon(params3);
+  const out = compiled.kind === "actions" ? { ...data, alias_map: data?.alias_map ?? compiled.aliasMap } : data;
+  yield* writeSuccess({
+    data: out,
+    ids: [data.txn_id, ...data.op_ids],
+    md: `- txn_id: ${data.txn_id}
+- op_ids: ${data.op_ids.length}
+- notified: ${data.notified}
+- sent: ${data.sent ?? ""}
+`
   });
-}
+}).pipe(catchAll2(writeFailure)));
 
 // src/commands/api/ensure.ts
 function optionToUndefined17(opt) {
@@ -103017,203 +103384,6 @@ var pluginCurrentCommand = exports_Command.make("current", { stateFile: stateFil
   yield* writeSuccess({ data: out, ids: ids3, md });
 }).pipe(catchAll2(writeFailure)));
 
-// src/lib/pluginServerHealth.ts
-function checkPluginServerHealth(baseUrl, timeoutMs3) {
-  return tryPromise2({
-    try: async () => {
-      const controller = new AbortController;
-      const timer2 = setTimeout(() => controller.abort(), timeoutMs3);
-      try {
-        const res = await fetch(`${baseUrl}/manifest.json`, { signal: controller.signal });
-        if (!res.ok) {
-          throw new Error(`Unexpected response status: ${res.status}`);
-        }
-        return { base_url: baseUrl };
-      } finally {
-        clearTimeout(timer2);
-      }
-    },
-    catch: (error4) => new CliError({
-      code: "PLUGIN_UNAVAILABLE",
-      message: "Plugin server is unavailable",
-      exitCode: 1,
-      details: { base_url: baseUrl, error: String(error4?.message || error4) }
-    })
-  });
-}
-function waitForPluginServerHealth(baseUrl, waitMs, timeoutMs3) {
-  return gen2(function* () {
-    if (!Number.isFinite(waitMs) || waitMs < 0) {
-      return yield* fail8(new CliError({
-        code: "INVALID_ARGS",
-        message: "--wait must be a non-negative integer (ms)",
-        exitCode: 2,
-        details: { wait_ms: waitMs }
-      }));
-    }
-    if (waitMs === 0)
-      return;
-    const deadline = Date.now() + waitMs;
-    while (Date.now() < deadline) {
-      const remaining = Math.max(0, deadline - Date.now());
-      const res = yield* checkPluginServerHealth(baseUrl, Math.min(timeoutMs3, Math.max(1, remaining))).pipe(either3);
-      if (isRight2(res))
-        return;
-      yield* sleep4(millis(300));
-    }
-    return yield* fail8(new CliError({
-      code: "PLUGIN_UNAVAILABLE",
-      message: `Timed out waiting for plugin server to become available (${waitMs}ms)`,
-      exitCode: 1,
-      details: { base_url: baseUrl, wait_ms: waitMs },
-      hint: ["agent-remnote plugin status --json", "agent-remnote plugin logs --lines 200"]
-    }));
-  });
-}
-
-// src/commands/plugin/_shared.ts
-var PLUGIN_SERVER_HEALTH_TIMEOUT_MS = 2000;
-var PLUGIN_SERVER_START_WAIT_DEFAULT_MS = 15000;
-var PLUGIN_SERVER_STOP_WAIT_DEFAULT_MS = 5000;
-var PLUGIN_SERVER_DEFAULT_HOST = "127.0.0.1";
-var PLUGIN_SERVER_DEFAULT_PORT = 8080;
-function pluginServerLocalBaseUrl(host5, port7) {
-  const normalizedHost = host5 === "0.0.0.0" || host5 === "::" ? "127.0.0.1" : host5;
-  return `http://${normalizedHost}:${port7}`;
-}
-function childCommandLine3(params3) {
-  const command = process.argv[0];
-  const script = process.argv[1];
-  if (!command || !script) {
-    throw new CliError({
-      code: "INTERNAL",
-      message: "Unable to determine the current executable entrypoint (process.argv is incomplete)",
-      exitCode: 1,
-      details: { argv: process.argv }
-    });
-  }
-  const execArgv = Array.isArray(process.execArgv) ? process.execArgv : [];
-  const args2 = [...execArgv, script, "plugin", "serve", "--host", params3.host, "--port", String(params3.port), "--state-file", params3.stateFile];
-  return { command, args: args2 };
-}
-function toPidFileValue3(params3) {
-  return {
-    pid: params3.pid,
-    build: currentRuntimeBuildInfo(),
-    started_at: params3.startedAt,
-    host: params3.host,
-    port: params3.port,
-    log_file: params3.logFile,
-    state_file: params3.stateFile,
-    cmd: params3.cmd
-  };
-}
-function startPluginServer(params3) {
-  return gen2(function* () {
-    const files = yield* PluginServerFiles;
-    const proc = yield* Process;
-    const host5 = params3.host ?? PLUGIN_SERVER_DEFAULT_HOST;
-    const port7 = params3.port ?? PLUGIN_SERVER_DEFAULT_PORT;
-    const pidFilePath = resolveUserFilePath(params3.pidFile ?? files.defaultPidFile());
-    const logFilePath = resolveUserFilePath(params3.logFile ?? files.defaultLogFile());
-    const stateFilePath = resolveUserFilePath(params3.stateFile ?? files.defaultStateFile());
-    const baseUrl = pluginServerLocalBaseUrl(host5, port7);
-    const existing = yield* files.readPidFile(pidFilePath);
-    if (existing) {
-      const alive = yield* proc.isPidRunning(existing.pid);
-      if (!alive) {
-        yield* files.deletePidFile(pidFilePath);
-      } else {
-        yield* requireTrustedPidRecord({ record: existing, pidFilePath });
-        return {
-          started: false,
-          pid: existing.pid,
-          pid_file: pidFilePath,
-          log_file: existing.log_file ?? logFilePath,
-          state_file: existing.state_file ?? stateFilePath,
-          base_url: baseUrl
-        };
-      }
-    }
-    const pre = yield* checkPluginServerHealth(baseUrl, PLUGIN_SERVER_HEALTH_TIMEOUT_MS).pipe(either3);
-    if (isRight2(pre)) {
-      return {
-        started: false,
-        pid_file: pidFilePath,
-        log_file: logFilePath,
-        state_file: stateFilePath,
-        base_url: baseUrl
-      };
-    }
-    const cmd = yield* try_3({
-      try: () => childCommandLine3({ host: host5, port: port7, stateFile: stateFilePath }),
-      catch: (error4) => isCliError(error4) ? error4 : new CliError({
-        code: "INTERNAL",
-        message: "Failed to start plugin server",
-        exitCode: 1,
-        details: { error: String(error4?.message || error4) }
-      })
-    });
-    const pid = yield* proc.spawnDetached({ command: cmd.command, args: cmd.args, logFile: logFilePath });
-    yield* files.writePidFile(pidFilePath, toPidFileValue3({
-      pid,
-      startedAt: Date.now(),
-      host: host5,
-      port: port7,
-      logFile: logFilePath,
-      stateFile: stateFilePath,
-      cmd: [cmd.command, ...cmd.args]
-    }));
-    yield* waitForPluginServerHealth(baseUrl, params3.waitMs, PLUGIN_SERVER_HEALTH_TIMEOUT_MS);
-    return {
-      started: true,
-      pid,
-      pid_file: pidFilePath,
-      log_file: logFilePath,
-      state_file: stateFilePath,
-      base_url: baseUrl
-    };
-  });
-}
-function ensurePluginServer(params3) {
-  return gen2(function* () {
-    const files = yield* PluginServerFiles;
-    const proc = yield* Process;
-    const host5 = params3.host ?? PLUGIN_SERVER_DEFAULT_HOST;
-    const port7 = params3.port ?? PLUGIN_SERVER_DEFAULT_PORT;
-    const pidFilePath = resolveUserFilePath(params3.pidFile ?? files.defaultPidFile());
-    const logFilePath = resolveUserFilePath(params3.logFile ?? files.defaultLogFile());
-    const stateFilePath = resolveUserFilePath(params3.stateFile ?? files.defaultStateFile());
-    const baseUrl = pluginServerLocalBaseUrl(host5, port7);
-    const pre = yield* checkPluginServerHealth(baseUrl, PLUGIN_SERVER_HEALTH_TIMEOUT_MS).pipe(either3);
-    if (isRight2(pre)) {
-      const existing = yield* files.readPidFile(pidFilePath);
-      if (existing) {
-        const alive = yield* proc.isPidRunning(existing.pid);
-        if (alive) {
-          yield* requireTrustedPidRecord({ record: existing, pidFilePath });
-          return {
-            started: false,
-            pid: existing.pid,
-            pid_file: pidFilePath,
-            log_file: existing.log_file ?? logFilePath,
-            state_file: existing.state_file ?? stateFilePath,
-            base_url: baseUrl
-          };
-        }
-      }
-      return {
-        started: false,
-        pid_file: pidFilePath,
-        log_file: logFilePath,
-        state_file: stateFilePath,
-        base_url: baseUrl
-      };
-    }
-    return yield* startPluginServer(params3);
-  });
-}
-
 // src/commands/plugin/ensure.ts
 function optionToUndefined33(opt) {
   return isSome2(opt) ? opt.value : undefined;