@openscout/scout 0.2.23 → 0.2.25

package/dist/scout-web-server.mjs

@@ -8029,7 +8029,7 @@ var SCOUT_APP_VERSION = "0.2.23";
 // apps/desktop/src/shared/surface-capabilities.ts
 function resolveScoutSurfaceCapabilities(surface) {
   switch (surface) {
-    case "electron":
+    case "desktop":
       return {
         canProvisionRuntime: true,
         canManageBroker: true,
@@ -8074,6 +8074,9 @@ import { basename as basename2, dirname as dirname4, join as join5 } from "path"
 import { existsSync as existsSync4 } from "fs";
 import { fileURLToPath as fileURLToPath3 } from "url";
 import { homedir as homedir4 } from "os";
+var BROKER_STATUS_CACHE_TTL_MS = 2000;
+var cachedBrokerStatus = null;
+var inflightBrokerStatus = null;
 function tryWhich(executableName) {
   const pathEnv = process.env.PATH ?? "";
   const sep = process.platform === "win32" ? ";" : ":";
@@ -8185,6 +8188,9 @@ function spawnArgsForRuntime(entry, serviceArgs) {
   return { command: entry, args: ["service", ...serviceArgs] };
 }
 async function runRuntimeBrokerService(subcommand) {
+  if (subcommand !== "status") {
+    invalidateRuntimeBrokerServiceStatus();
+  }
   const entry = resolveRuntimeServiceEntrypoint();
   const { command, args } = spawnArgsForRuntime(entry, [subcommand, "--json"]);
   const stdoutChunks = [];
@@ -8212,13 +8218,31 @@ async function runRuntimeBrokerService(subcommand) {
     throw new Error(`openscout-runtime service ${subcommand} failed: ${detail}`);
   }
   try {
-    return JSON.parse(stdout);
+    const parsed = JSON.parse(stdout);
+    cachedBrokerStatus = {
+      value: parsed,
+      expiresAt: Date.now() + BROKER_STATUS_CACHE_TTL_MS
+    };
+    return parsed;
   } catch {
     throw new Error(`openscout-runtime service ${subcommand} returned non-JSON stdout: ${stdout.slice(0, 400)}`);
   }
 }
-async function getRuntimeBrokerServiceStatus() {
-  return runRuntimeBrokerService("status");
+function invalidateRuntimeBrokerServiceStatus() {
+  cachedBrokerStatus = null;
+}
+async function getRuntimeBrokerServiceStatus(options = {}) {
+  const force = options.force ?? false;
+  if (!force && cachedBrokerStatus && cachedBrokerStatus.expiresAt > Date.now()) {
+    return cachedBrokerStatus.value;
+  }
+  if (!force && inflightBrokerStatus) {
+    return inflightBrokerStatus;
+  }
+  inflightBrokerStatus = runRuntimeBrokerService("status").finally(() => {
+    inflightBrokerStatus = null;
+  });
+  return inflightBrokerStatus;
 }
 
 // apps/desktop/src/core/broker/service.ts
@@ -8250,6 +8274,7 @@ var BROKER_SHARED_CHANNEL_ID = "channel.shared";
 var OPERATOR_ID = "operator";
 var DEFAULT_BROKER_HOST2 = "127.0.0.1";
 var DEFAULT_BROKER_PORT2 = 65535;
+var BUILT_IN_SCOUT_AGENT_IDS = new Set([SCOUT_AGENT_ID, "builder", "reviewer", "research"]);
 function buildScoutBrokerUrlFromEnv() {
   const host = process.env.OPENSCOUT_BROKER_HOST ?? DEFAULT_BROKER_HOST2;
   const port = Number.parseInt(process.env.OPENSCOUT_BROKER_PORT ?? String(DEFAULT_BROKER_PORT2), 10);
@@ -8828,7 +8853,9 @@ function runOptionalCommand(command, args) {
 
 // apps/desktop/src/app/desktop/shell-probes.ts
 var PROJECT_GIT_ACTIVITY_CACHE_TTL_MS = 60000;
+var TMUX_SESSION_CACHE_TTL_MS = 2000;
 var projectGitActivityCache = new Map;
+var tmuxSessionCache = null;
 function readHelperStatus() {
   const statusPath = resolveOpenScoutSupportPaths().desktopStatusPath;
   if (!existsSync7(statusPath)) {
@@ -8854,9 +8881,12 @@ function readHelperStatus() {
   }
 }
 function readTmuxSessions() {
+  if (tmuxSessionCache && Date.now() - tmuxSessionCache.cachedAt < TMUX_SESSION_CACHE_TTL_MS) {
+    return tmuxSessionCache.sessions;
+  }
   try {
     const stdout = readTmuxSessionOutput();
-    return stdout.split(`
+    const sessions3 = stdout.split(`
 `).map((line) => line.trim()).filter(Boolean).map((line) => {
       const [name, createdAtRaw] = line.split("\t");
       return {
@@ -8864,6 +8894,11 @@ function readTmuxSessions() {
         createdAt: createdAtRaw ? Number.parseInt(createdAtRaw, 10) : null
       };
     });
+    tmuxSessionCache = {
+      cachedAt: Date.now(),
+      sessions: sessions3
+    };
+    return sessions3;
   } catch {
     return [];
   }
@@ -8988,8 +9023,6 @@ function activeEndpoint(snapshot, actorId) {
         return 1;
       case "waiting":
         return 2;
-      case "degraded":
-        return 3;
       case "offline":
         return 5;
       default:
@@ -9455,7 +9488,7 @@ function machineEndpointState(endpoint, activity) {
   if (endpoint.state === "idle") {
     return "idle";
   }
-  if (endpoint.state === "waiting" || endpoint.state === "degraded") {
+  if (endpoint.state === "waiting") {
     return "waiting";
   }
   return "offline";
@@ -10923,7 +10956,7 @@ function createScoutDesktopFeatureFlags(input = {}) {
 function createScoutDesktopAppInfo(input = {}) {
   const configuredProductName = process.env.SCOUT_PRODUCT_NAME?.trim();
   const configuredAppVersion = process.env.SCOUT_APP_VERSION?.trim();
-  const surface = input.surface ?? "electron";
+  const surface = input.surface ?? "desktop";
   return {
     productName: input.productName ?? configuredProductName ?? SCOUT_PRODUCT_NAME,
     appVersion: input.appVersion ?? configuredAppVersion ?? SCOUT_APP_VERSION,
@@ -11009,8 +11042,6 @@ function activeEndpoint2(snapshot, agentId) {
         return 1;
       case "waiting":
         return 2;
-      case "degraded":
-        return 3;
       case "offline":
         return 5;
       default:
@@ -11127,7 +11158,7 @@ function buildBrokerAgentConfigState(agentId, snapshot) {
     capabilitiesText: Array.isArray(agent.capabilities) ? agent.capabilities.join(", ") : ""
   };
 }
-async function getScoutElectronAgentConfig(agentId) {
+async function getScoutDesktopAgentConfig(agentId) {
   const agentConfig = await getLocalAgentConfig(agentId);
   if (agentConfig) {
     return buildLocalAgentConfigState2(agentId, agentConfig);
@@ -11138,7 +11169,7 @@ async function getScoutElectronAgentConfig(agentId) {
   }
   return buildBrokerAgentConfigState(agentId, broker.snapshot);
 }
-async function updateScoutElectronAgentConfig(input) {
+async function updateScoutDesktopAgentConfig(input) {
   const nextConfig = await updateLocalAgentConfig(input.agentId, {
     runtime: {
       cwd: input.runtime.cwd,
@@ -11259,7 +11290,7 @@ function buildOptimisticBrokerRelayMessage(input) {
     isVoice,
     messageClass: isSystem ? "system" : "agent",
     routingSummary: input.recipients.length > 0 ? `Targets ${input.recipients.join(", ")}` : null,
-    provenanceSummary: "via electron",
+    provenanceSummary: "via desktop",
     provenanceDetail: null,
     isOperator: true,
     avatarLabel: input.operatorName.slice(0, 1).toUpperCase() || "A",
@@ -11364,7 +11395,7 @@ async function ensureOperatorActor(baseUrl, snapshot, operatorName) {
     displayName: operatorName,
     handle: SCOUT_BROKER_OPERATOR_ID,
     labels: ["operator", "desktop"],
-    metadata: { source: "scout-electron" }
+    metadata: { source: "scout-desktop" }
   };
   await postBrokerJson(baseUrl, "/v1/actors", actor);
   snapshot.actors[actor.id] = actor;
@@ -11382,7 +11413,7 @@ async function ensureCoreConversation(baseUrl, snapshot, nodeId, conversationId)
     shareMode: "shared",
     authorityNodeId: nodeId,
     participantIds,
-    metadata: { surface: "scout-electron" }
+    metadata: { surface: "scout-desktop" }
   } : conversationId === SCOUT_VOICE_CHANNEL_ID ? {
     id: SCOUT_VOICE_CHANNEL_ID,
     kind: "channel",
@@ -11391,7 +11422,7 @@ async function ensureCoreConversation(baseUrl, snapshot, nodeId, conversationId)
     shareMode: "local",
     authorityNodeId: nodeId,
     participantIds,
-    metadata: { surface: "scout-electron" }
+    metadata: { surface: "scout-desktop" }
   } : {
     id: SCOUT_SYSTEM_CHANNEL_ID,
     kind: "system",
@@ -11400,7 +11431,7 @@ async function ensureCoreConversation(baseUrl, snapshot, nodeId, conversationId)
     shareMode: "local",
     authorityNodeId: nodeId,
     participantIds: [SCOUT_BROKER_OPERATOR_ID],
-    metadata: { surface: "scout-electron" }
+    metadata: { surface: "scout-desktop" }
   };
   await postBrokerJson(baseUrl, "/v1/conversations", definition);
   snapshot.conversations[conversationId] = definition;
@@ -11421,7 +11452,7 @@ async function ensureDirectConversation(baseUrl, snapshot, nodeId, agentId, oper
     authorityNodeId: nodeId,
     participantIds: [SCOUT_BROKER_OPERATOR_ID, agentId].sort(),
     metadata: {
-      surface: "scout-electron",
+      surface: "scout-desktop",
       ...agentId === SCOUT_AGENT_ID2 ? { role: "partner" } : {}
     }
   };
@@ -11549,7 +11580,7 @@ function parseRequestedHarness(value) {
   }
   return SUPPORTED_LOCAL_AGENT_HARNESSES.includes(value) ? value : undefined;
 }
-async function restartScoutElectronAgent(input, options = {}) {
+async function restartScoutDesktopAgent(input, options = {}) {
   const currentDirectory = resolveCurrentDirectory(options.currentDirectory);
   const operatorName = await resolveOperatorDisplayName2(currentDirectory);
   const record = await restartLocalAgent(input.agentId, {
@@ -11565,7 +11596,7 @@ async function restartScoutElectronAgent(input, options = {}) {
   });
   return loadBrokerActionShellState(options);
 }
-async function createScoutElectronAgent(input, options = {}) {
+async function createScoutDesktopAgent(input, options = {}) {
   const currentDirectory = resolveCurrentDirectory(options.currentDirectory);
   const operatorName = await resolveOperatorDisplayName2(currentDirectory);
   const projectPath = input.projectPath.trim();
@@ -11588,7 +11619,7 @@ async function createScoutElectronAgent(input, options = {}) {
     shellState: await loadBrokerActionShellState(options)
   };
 }
-async function controlScoutElectronBroker(action, options = {}) {
+async function controlScoutDesktopBroker(action, options = {}) {
   const currentDirectory = resolveCurrentDirectory(options.currentDirectory);
   const operatorName = await resolveOperatorDisplayName2(currentDirectory);
   switch (action) {
@@ -11616,7 +11647,7 @@ async function controlScoutElectronBroker(action, options = {}) {
   }
   return loadBrokerActionShellState(options);
 }
-async function sendScoutElectronRelayMessage(input, options = {}) {
+async function sendScoutDesktopRelayMessage(input, options = {}) {
   const currentDirectory = resolveCurrentDirectory(options.currentDirectory);
   const operatorName = await resolveOperatorDisplayName2(currentDirectory);
   const broker = await loadScoutBrokerContext();
@@ -11678,7 +11709,7 @@ async function sendScoutElectronRelayMessage(input, options = {}) {
     policy: "durable",
     createdAt,
     metadata: {
-      source: "scout-electron",
+      source: "scout-desktop",
       destinationKind: input.destinationKind,
       destinationId: input.destinationId,
       referenceMessageIds,
@@ -11706,7 +11737,7 @@ async function sendScoutElectronRelayMessage(input, options = {}) {
       stream: false,
       createdAt,
       metadata: {
-        source: "scout-electron",
+        source: "scout-desktop",
         destinationKind: input.destinationKind
       }
     });
@@ -11754,18 +11785,6 @@ function looksLikeWorkspaceRoot(candidate) {
   }
 }
 function looksLikePackagedAppRoot(candidate) {
-  const packageJsonPath = join10(candidate, "package.json");
-  if (!existsSync8(packageJsonPath)) {
-    return false;
-  }
-  try {
-    const parsed = JSON.parse(readFileSync5(packageJsonPath, "utf8"));
-    return parsed.name === "@scout/electron-app";
-  } catch {
-    return false;
-  }
-}
-function looksLikeInstalledCliRoot(candidate) {
   const packageJsonPath = join10(candidate, "package.json");
   if (!existsSync8(packageJsonPath)) {
     return false;
@@ -11830,14 +11849,8 @@ function resolveScoutAppRoot(options = {}) {
       return packagedRoot;
     }
   }
-  for (const start of starts) {
-    const installedCliRoot = findMatchingAncestor(start, looksLikeInstalledCliRoot);
-    if (installedCliRoot) {
-      return installedCliRoot;
-    }
-  }
   const workspaceRoot = resolveScoutWorkspaceRoot(options);
-  for (const relativePath of [["apps", "desktop"], ["apps", "scout"]]) {
+  for (const relativePath of [["apps", "desktop"], ["apps", "scout"], ["packages", "cli"]]) {
     const candidate = resolve5(workspaceRoot, ...relativePath);
     if (looksLikeSourceAppRoot(candidate)) {
       return candidate;
@@ -12341,9 +12354,8 @@ function resolveScoutBunExecutable() {
 function resolveScoutPairingRuntimeScriptPath() {
   const appRoot = resolveScoutAppRoot();
   const candidates = [
-    join11(appRoot, "dist", "electron", SCOUT_PAIRING_RUNTIME_SCRIPT.replace(/\.ts$/, ".js")),
-    join11(appRoot, "bin", SCOUT_PAIRING_RUNTIME_SCRIPT),
-    join11(appRoot, "..", "..", "packages", "electron-app", "dist", "electron", SCOUT_PAIRING_RUNTIME_SCRIPT.replace(/\.ts$/, ".js"))
+    join11(appRoot, "dist", SCOUT_PAIRING_RUNTIME_SCRIPT.replace(/\.ts$/, ".mjs")),
+    join11(appRoot, "bin", SCOUT_PAIRING_RUNTIME_SCRIPT)
   ];
   for (const candidate of candidates) {
     if (existsSync9(candidate)) {
@@ -12513,13 +12525,13 @@ async function ensureScoutPairingRuntimeStarted() {
   }
   await startScoutPairingRuntime();
 }
-async function getScoutElectronPairingState(currentDirectory) {
+async function getScoutDesktopPairingState(currentDirectory) {
   return readScoutPairingState(currentDirectory);
 }
-async function refreshScoutElectronPairingState(currentDirectory) {
+async function refreshScoutDesktopPairingState(currentDirectory) {
   return readScoutPairingState(currentDirectory);
 }
-async function controlScoutElectronPairingService(action, currentDirectory) {
+async function controlScoutDesktopPairingService(action, currentDirectory) {
   switch (action) {
     case "start":
       await ensureDefaultScoutPairingWorkspaceConfig(currentDirectory);
@@ -12535,14 +12547,14 @@ async function controlScoutElectronPairingService(action, currentDirectory) {
   }
   return readScoutPairingState(currentDirectory);
 }
-async function updateScoutElectronPairingConfig(input, currentDirectory) {
+async function updateScoutDesktopPairingConfig(input, currentDirectory) {
   await updateScoutPairingConfig(input, currentDirectory);
   if (isScoutPairingRuntimeRunning()) {
     await restartScoutPairingRuntime();
   }
   return readScoutPairingState(currentDirectory);
 }
-async function decideScoutElectronPairingApproval(input, currentDirectory) {
+async function decideScoutDesktopPairingApproval(input, currentDirectory) {
   const resolvedConfig = resolveScoutPairingConfig();
   await withScoutPairingBridgeClient(resolvedConfig.port, async (client) => {
     await client.mutation("actionDecide", {
@@ -12642,7 +12654,7 @@ function deriveScoutTelegramBridgeRuntimeState(input) {
   });
 }
 // apps/desktop/src/app/host/settings.ts
-var SCOUT_ELECTRON_OPENER = "scout";
+var SCOUT_CLI_COMMAND = "scout";
 function compactHomePath4(value) {
   if (!value) {
     return null;
@@ -12686,7 +12698,7 @@ function defaultOnboardingContextRoot(explicitRoot, workspaceRoots, fallback) {
 function isExecutable3(candidate) {
   return existsSync10(candidate);
 }
-function resolveScoutElectronScoutExecutable() {
+function resolveScoutDesktopScoutExecutable() {
   const explicit = process.env.OPENSCOUT_SCOUT_BIN ?? process.env.SCOUT_BIN;
   if (explicit?.trim()) {
     return explicit.trim();
@@ -12698,14 +12710,14 @@ function resolveScoutElectronScoutExecutable() {
     "/usr/local/bin"
   ];
   for (const directory of [...pathEntries, ...commonDirectories]) {
-    const candidate = path4.join(directory.replace(/^~(?=$|\/)/, homedir8()), SCOUT_ELECTRON_OPENER);
+    const candidate = path4.join(directory.replace(/^~(?=$|\/)/, homedir8()), SCOUT_CLI_COMMAND);
     if (isExecutable3(candidate)) {
       return candidate;
     }
   }
   throw new Error(buildMissingScoutCliMessage());
 }
-function resolveScoutElectronBunInstallCommand() {
+function resolveScoutDesktopBunInstallCommand() {
   const pathEntries = (process.env.PATH ?? "").split(":").filter(Boolean);
   const brewCandidates = [
     ...pathEntries.map((entry) => path4.join(entry, "brew")),
@@ -12720,7 +12732,7 @@ function resolveScoutElectronBunInstallCommand() {
   return "curl -fsSL https://bun.sh/install | bash";
 }
 function buildMissingScoutCliMessage() {
-  const bunInstallCommand = resolveScoutElectronBunInstallCommand();
+  const bunInstallCommand = resolveScoutDesktopBunInstallCommand();
   return [
     "Scout CLI was not found on this Mac.",
     "Install Bun, then install the Scout package globally:",
@@ -12788,7 +12800,7 @@ function resolveCurrentProjectConfigPath(onboardingContextRoot) {
   const candidate = path4.join(onboardingContextRoot, ".openscout", "project.json");
   return existsSync10(candidate) ? candidate : null;
 }
-async function loadScoutElectronSettingsBase(currentDirectory, services = {}, input = {}) {
+async function loadScoutDesktopSettingsBase(currentDirectory, services = {}, input = {}) {
   const settingsDirectory = resolveSettingsDirectory(currentDirectory);
   const supportPaths = resolveOpenScoutSupportPaths();
   const record = await readOpenScoutSettings({ currentDirectory: settingsDirectory });
@@ -12857,7 +12869,7 @@ async function loadScoutElectronSettingsBase(currentDirectory, services = {}, in
     telegram
   };
 }
-function buildScoutElectronAppSettingsState(base, input) {
+function buildScoutDesktopAppSettingsState(base, input) {
   const discoveredAgents = input.discoveredAgents ?? [];
   const projectInventory = input.projectInventory ?? [];
   return {
@@ -12995,14 +13007,14 @@ async function resolveTelegramSettingsState(input, services, readiness) {
     pendingDeliveries: runtimeState.pendingDeliveries
   };
 }
-async function getScoutElectronAppSettings(currentDirectory, services = {}) {
-  const base = await loadScoutElectronSettingsBase(currentDirectory, services);
-  return buildScoutElectronAppSettingsState(base, {
+async function getScoutDesktopAppSettings(currentDirectory, services = {}) {
+  const base = await loadScoutDesktopSettingsBase(currentDirectory, services);
+  return buildScoutDesktopAppSettingsState(base, {
     workspaceInventoryLoaded: false
   });
 }
-async function refreshScoutElectronAppSettingsInventory(currentDirectory, services = {}) {
-  const base = await loadScoutElectronSettingsBase(currentDirectory, services);
+async function refreshScoutDesktopAppSettingsInventory(currentDirectory, services = {}) {
+  const base = await loadScoutDesktopSettingsBase(currentDirectory, services);
   const setup = await loadResolvedRelayAgents({
     currentDirectory: base.onboardingContextRoot
   });
@@ -13036,7 +13048,7 @@ async function refreshScoutElectronAppSettingsInventory(currentDirectory, servic
     sessionId: agent.runtime.sessionId,
     projectConfigPath: agent.projectConfigPath ?? null
   })) : [];
-  return buildScoutElectronAppSettingsState(await loadScoutElectronSettingsBase(currentDirectory, services, {
+  return buildScoutDesktopAppSettingsState(await loadScoutDesktopSettingsBase(currentDirectory, services, {
     projectInventoryCount: projectInventory.length
   }), {
     workspaceInventoryLoaded: true,
@@ -13044,13 +13056,13 @@ async function refreshScoutElectronAppSettingsInventory(currentDirectory, servic
     projectInventory
   });
 }
-async function runScoutElectronOnboardingCommand(input, currentDirectory) {
+async function runScoutDesktopOnboardingCommand(input, currentDirectory) {
   const settingsDirectory = resolveSettingsDirectory(currentDirectory);
   const contextRoot = path4.resolve(expandHomePath5(input.contextRoot?.trim() || defaultOnboardingContextRoot(null, input.sourceRoots ?? [], settingsDirectory)));
-  const scoutExecutable = resolveScoutElectronScoutExecutable();
+  const scoutExecutable = resolveScoutDesktopScoutExecutable();
   const cliCommand = input.command === "setup" ? "setup" : input.command;
   const normalizedSourceRoots = Array.from(new Set((input.sourceRoots ?? []).map((entry) => expandHomePath5(entry).trim()).filter(Boolean)));
-  const displayArgs = [SCOUT_ELECTRON_OPENER, input.command, "--context-root", compactHomePath4(contextRoot) ?? contextRoot];
+  const displayArgs = [SCOUT_CLI_COMMAND, input.command, "--context-root", compactHomePath4(contextRoot) ?? contextRoot];
   const execArgs = [cliCommand, "--context-root", contextRoot];
   if (input.command === "setup") {
     for (const sourceRoot of normalizedSourceRoots) {
@@ -13113,7 +13125,7 @@ async function runScoutElectronOnboardingCommand(input, currentDirectory) {
   }
   return result;
 }
-async function skipScoutElectronOnboarding(currentDirectory, services = {}) {
+async function skipScoutDesktopOnboarding(currentDirectory, services = {}) {
   await writeOpenScoutSettings({
     onboarding: {
       skippedAt: Date.now()
@@ -13121,9 +13133,9 @@ async function skipScoutElectronOnboarding(currentDirectory, services = {}) {
   }, {
     currentDirectory: resolveSettingsDirectory(currentDirectory)
   });
-  return getScoutElectronAppSettings(currentDirectory, services);
+  return getScoutDesktopAppSettings(currentDirectory, services);
 }
-async function restartScoutElectronOnboarding(currentDirectory, services = {}) {
+async function restartScoutDesktopOnboarding(currentDirectory, services = {}) {
   await writeOpenScoutSettings({
     onboarding: {
       operatorAnsweredAt: null,
@@ -13139,9 +13151,9 @@ async function restartScoutElectronOnboarding(currentDirectory, services = {}) {
   }, {
     currentDirectory: resolveSettingsDirectory(currentDirectory)
   });
-  return getScoutElectronAppSettings(currentDirectory, services);
+  return getScoutDesktopAppSettings(currentDirectory, services);
 }
-async function updateScoutElectronAppSettings(input, currentDirectory, services = {}) {
+async function updateScoutDesktopAppSettings(input, currentDirectory, services = {}) {
   const trimmedOperatorName = input.operatorName?.trim() ?? "";
   const trimmedContextRoot = input.onboardingContextRoot?.trim() ?? "";
   const defaultHarness = SUPPORTED_LOCAL_AGENT_HARNESSES.includes(input.defaultHarness) ? input.defaultHarness : "claude";
@@ -13198,7 +13210,7 @@ async function updateScoutElectronAppSettings(input, currentDirectory, services
       });
     } catch {}
   }
-  return getScoutElectronAppSettings(currentDirectory, services);
+  return getScoutDesktopAppSettings(currentDirectory, services);
 }
 async function updateHiddenProjectRoots(nextHiddenProjectRoots, currentDirectory, services = {}) {
   const settingsDirectory = resolveSettingsDirectory(currentDirectory);
@@ -13224,14 +13236,14 @@ async function updateHiddenProjectRoots(nextHiddenProjectRoots, currentDirectory
       });
     } catch {}
   }
-  return refreshScoutElectronAppSettingsInventory(currentDirectory, services);
+  return refreshScoutDesktopAppSettingsInventory(currentDirectory, services);
 }
-async function retireScoutElectronProject(projectRoot, currentDirectory, services = {}) {
+async function retireScoutDesktopProject(projectRoot, currentDirectory, services = {}) {
   const settingsDirectory = resolveSettingsDirectory(currentDirectory);
   const currentSettings = await readOpenScoutSettings({ currentDirectory: settingsDirectory });
   return updateHiddenProjectRoots([...normalizedHiddenProjectRoots(currentSettings.discovery.hiddenProjectRoots), projectRoot], currentDirectory, services);
 }
-async function restoreScoutElectronProject(projectRoot, currentDirectory, services = {}) {
+async function restoreScoutDesktopProject(projectRoot, currentDirectory, services = {}) {
   const settingsDirectory = resolveSettingsDirectory(currentDirectory);
   const currentSettings = await readOpenScoutSettings({ currentDirectory: settingsDirectory });
   const normalizedProjectRoot = path4.resolve(expandHomePath5(projectRoot));
@@ -13459,8 +13471,8 @@ function appModeLabel() {
     const packageJsonPath = path5.join(appRoot, "package.json");
     if (existsSync11(packageJsonPath)) {
       const payload = JSON.parse(readFileSync7(packageJsonPath, "utf8"));
-      if (payload.name === "@scout/electron-app") {
-        return "packaged";
+      if (payload.name === "@openscout/scout" || payload.name === "@openscout/cli") {
+        return "installed";
       }
     }
   } catch {}
@@ -13506,11 +13518,10 @@ function coreLogSources() {
     {
       id: "app",
       title: "Desktop App",
-      subtitle: "Electron and local app logs",
+      subtitle: "Desktop host and local app logs",
       group: "app",
       pathLabel: compactHomePath5(supportPaths.appLogsDirectory) ?? supportPaths.appLogsDirectory,
       paths: [
-        path5.join(supportPaths.appLogsDirectory, "electron.log"),
         path5.join(supportPaths.appLogsDirectory, "native.log"),
         path5.join(supportPaths.appLogsDirectory, "agent-host.log")
       ]
@@ -13614,14 +13625,14 @@ async function tailScoutLogSource(source, tailLines = DEFAULT_LOG_TAIL_LINES) {
     missing: !foundAny
   };
 }
-async function getScoutElectronLogCatalog(_currentDirectory = process.cwd()) {
+async function getScoutDesktopLogCatalog(_currentDirectory = process.cwd()) {
   const sources = coreLogSources();
   return {
     sources: sources.map(({ paths: _paths, ...source }) => source),
     defaultSourceId: "broker"
   };
 }
-async function getScoutElectronBrokerInspector() {
+async function getScoutDesktopBrokerInspector() {
   const status = await getRuntimeBrokerServiceStatus();
   const processId = resolveBrokerProcessId(status.brokerUrl, status.pid);
   const processCommand = readProcessCommand(processId);
@@ -13661,7 +13672,7 @@ async function getScoutElectronBrokerInspector() {
     feedbackSummary: brokerFeedbackSummary(status, processId, processCommand, lastRestartLabel, version)
   };
 }
-async function readScoutElectronLogSource(input, _currentDirectory = process.cwd()) {
+async function readScoutDesktopLogSource(input, _currentDirectory = process.cwd()) {
   const sources = coreLogSources();
   const source = sources.find((entry) => entry.id === input.sourceId);
   if (!source) {
@@ -13671,12 +13682,12 @@ async function readScoutElectronLogSource(input, _currentDirectory = process.cwd
   const tailLines = Math.min(input.tailLines ?? DEFAULT_LOG_TAIL_LINES, MAX_TAIL_LINES);
   return tailScoutLogSource(source, tailLines);
 }
-async function getScoutElectronFeedbackBundle(currentDirectory = process.cwd()) {
+async function getScoutDesktopFeedbackBundle(currentDirectory = process.cwd()) {
   const generatedAt = new Date().toISOString();
   const supportPaths = resolveOpenScoutSupportPaths();
-  const appSettings = await getScoutElectronAppSettings(currentDirectory);
-  const pairingState = await getScoutElectronPairingState(currentDirectory);
-  const brokerInspector = await getScoutElectronBrokerInspector();
+  const appSettings = await getScoutDesktopAppSettings(currentDirectory);
+  const pairingState = await getScoutDesktopPairingState(currentDirectory);
+  const brokerInspector = await getScoutDesktopBrokerInspector();
   const appRoot = (() => {
     try {
       return compactHomePath5(resolveScoutAppRoot()) ?? resolveScoutAppRoot();
@@ -13779,14 +13790,14 @@ async function getScoutElectronFeedbackBundle(currentDirectory = process.cwd())
     text: serializeFeedbackSections(sections)
   };
 }
-async function submitScoutElectronFeedbackReport(input, currentDirectory = process.cwd()) {
+async function submitScoutDesktopFeedbackReport(input, currentDirectory = process.cwd()) {
   const message = input.message.trim();
   if (message.length === 0) {
     throw new Error("Feedback message is required.");
   }
-  const bundle = await getScoutElectronFeedbackBundle(currentDirectory);
-  const pairingState = await getScoutElectronPairingState(currentDirectory);
-  const brokerInspector = await getScoutElectronBrokerInspector();
+  const bundle = await getScoutDesktopFeedbackBundle(currentDirectory);
+  const pairingState = await getScoutDesktopPairingState(currentDirectory);
+  const brokerInspector = await getScoutDesktopBrokerInspector();
   const endpoint = resolveScoutFeedbackReportUrl();
   const reportId = randomUUID2();
   const report = {
@@ -13852,7 +13863,7 @@ async function submitScoutElectronFeedbackReport(input, currentDirectory = proce
   };
 }
 
-// apps/desktop/src/app/electron/host.ts
+// apps/desktop/src/app/host/native-host.ts
 import { existsSync as existsSync12 } from "fs";
 import { stat as stat5 } from "fs/promises";
 import path6 from "path";
@@ -13868,27 +13879,27 @@ function expandHomePath6(value) {
   }
   return value;
 }
-async function pickScoutElectronDirectory(host = {}) {
+async function pickScoutHostDirectory(host = {}) {
   if (!host.pickDirectory) {
     throw new Error("Scout directory picker is unavailable.");
   }
   return host.pickDirectory();
 }
-async function quitScoutElectronApp(host = {}) {
+async function quitScoutHostApp(host = {}) {
   if (!host.requestQuit) {
     throw new Error("Scout app quit is unavailable.");
   }
   host.requestQuit();
   return true;
 }
-async function reloadScoutElectronApp(host = {}) {
+async function reloadScoutHostApp(host = {}) {
   if (!host.reloadWindow) {
     throw new Error("Scout app reload is unavailable.");
   }
   host.reloadWindow();
   return true;
 }
-async function revealScoutElectronPath(filePath, host = {}) {
+async function revealScoutHostPath(filePath, host = {}) {
   const targetPath = expandHomePath6(filePath);
   if (!targetPath) {
     return false;
@@ -13914,6 +13925,7 @@ async function revealScoutElectronPath(filePath, host = {}) {
   host.showItemInFolder(targetPath);
   return true;
 }
+
 // apps/desktop/src/app/host/keep-alive.ts
 var DEFAULT_KEEP_ALIVE_OPTIONS = {
   normal: {
@@ -14324,8 +14336,6 @@ function activeEndpoint3(snapshot, agentId) {
         return 1;
       case "waiting":
         return 2;
-      case "degraded":
-        return 3;
       case "offline":
         return 5;
       default:
@@ -14357,7 +14367,7 @@ function buildTmuxInspector(input) {
     missing: false
   };
 }
-async function getScoutElectronAgentSession(agentId) {
+async function getScoutDesktopAgentSession(agentId) {
   const [agentConfig, broker] = await Promise.all([
     getLocalAgentConfig(agentId),
     loadScoutBrokerContext()
@@ -14445,8 +14455,8 @@ async function getScoutElectronAgentSession(agentId) {
     missing: true
   };
 }
-async function openScoutElectronAgentSession(agentId, host = {}) {
-  const session = await getScoutElectronAgentSession(agentId);
+async function openScoutDesktopAgentSession(agentId, host = {}) {
+  const session = await getScoutDesktopAgentSession(agentId);
   const platform = host.platform ?? process.platform;
   if (session.mode === "tmux" && session.commandLabel) {
     if (platform !== "darwin") {
@@ -14481,14 +14491,14 @@ async function openScoutElectronAgentSession(agentId, host = {}) {
 function resolveCurrentDirectory2(input) {
   return input ?? process.cwd();
 }
-function getScoutElectronAppInfo(input = {}) {
-  return createScoutDesktopAppInfo({ ...input, surface: "electron" });
+function getScoutDesktopAppInfo(input = {}) {
+  return createScoutDesktopAppInfo({ ...input, surface: "desktop" });
 }
-async function getScoutElectronServicesState(options = {}) {
+async function getScoutDesktopServicesState(options = {}) {
   const currentDirectory = resolveCurrentDirectory2(options.currentDirectory);
   const [servicesState, pairingState] = await Promise.all([
     loadScoutDesktopServicesState(),
-    getScoutElectronPairingState(currentDirectory)
+    getScoutDesktopPairingState(currentDirectory)
   ]);
   const pairingService = {
     id: "pairing",
@@ -14511,11 +14521,11 @@ async function getScoutElectronServicesState(options = {}) {
     services: nextServices
   };
 }
-async function getScoutElectronHomeState(options = {}) {
+async function getScoutDesktopHomeState(options = {}) {
   const currentDirectory = resolveCurrentDirectory2(options.currentDirectory);
   return loadScoutDesktopHomeState({ currentDirectory });
 }
-async function applyScoutElectronVoiceToMessagesWorkspaceState(messagesWorkspaceState, voiceService) {
+async function applyScoutDesktopVoiceToMessagesWorkspaceState(messagesWorkspaceState, voiceService) {
   if (!voiceService?.getVoiceState) {
     return messagesWorkspaceState;
   }
@@ -14528,7 +14538,7 @@ async function applyScoutElectronVoiceToMessagesWorkspaceState(messagesWorkspace
     }
   };
 }
-async function applyScoutElectronVoiceToRelayShellPatch(relayShellPatch, voiceService) {
+async function applyScoutDesktopVoiceToRelayShellPatch(relayShellPatch, voiceService) {
   if (!voiceService?.getVoiceState) {
     return relayShellPatch;
   }
@@ -14541,17 +14551,17 @@ async function applyScoutElectronVoiceToRelayShellPatch(relayShellPatch, voiceSe
     }
   };
 }
-async function getScoutElectronMessagesWorkspaceState(options = {}) {
+async function getScoutDesktopMessagesWorkspaceState(options = {}) {
   const currentDirectory = resolveCurrentDirectory2(options.currentDirectory);
   const messagesWorkspaceState = await loadScoutDesktopMessagesWorkspaceState({ currentDirectory });
-  return applyScoutElectronVoiceToMessagesWorkspaceState(messagesWorkspaceState, options.voice);
+  return applyScoutDesktopVoiceToMessagesWorkspaceState(messagesWorkspaceState, options.voice);
 }
-async function getScoutElectronRelayShellPatch(options = {}) {
+async function getScoutDesktopRelayShellPatch(options = {}) {
   const currentDirectory = resolveCurrentDirectory2(options.currentDirectory);
   const relayShellPatch = await loadScoutDesktopRelayShellPatch({ currentDirectory });
-  return applyScoutElectronVoiceToRelayShellPatch(relayShellPatch, options.voice);
+  return applyScoutDesktopVoiceToRelayShellPatch(relayShellPatch, options.voice);
 }
-async function applyScoutElectronVoiceState(shellState, voiceService) {
+async function applyScoutDesktopVoiceState(shellState, voiceService) {
   if (!voiceService?.getVoiceState) {
     return shellState;
   }
@@ -14564,39 +14574,39 @@ async function applyScoutElectronVoiceState(shellState, voiceService) {
     }
   };
 }
-async function getScoutElectronShellState(options = {}) {
+async function getScoutDesktopShellState(options = {}) {
   const currentDirectory = resolveCurrentDirectory2(options.currentDirectory);
   const shellState = await loadScoutDesktopShellState({
     currentDirectory,
     appInfo: options.appInfo ?? createScoutDesktopAppInfo()
   });
-  return applyScoutElectronVoiceState(shellState, options.voice);
+  return applyScoutDesktopVoiceState(shellState, options.voice);
 }
-async function refreshScoutElectronShellState(options = {}) {
-  return getScoutElectronShellState(options);
+async function refreshScoutDesktopShellState(options = {}) {
+  return getScoutDesktopShellState(options);
 }
-async function refreshScoutElectronRelayShellPatch(options = {}) {
-  return getScoutElectronRelayShellPatch(options);
+async function refreshScoutDesktopRelayShellPatch(options = {}) {
+  return getScoutDesktopRelayShellPatch(options);
 }
-async function getScoutElectronPhonePreparation(currentDirectory = process.cwd()) {
+async function getScoutDesktopPhonePreparation(currentDirectory = process.cwd()) {
   return loadScoutPhonePreparation(currentDirectory);
 }
-async function updateScoutElectronPhonePreparation(input, currentDirectory = process.cwd()) {
+async function updateScoutDesktopPhonePreparation(input, currentDirectory = process.cwd()) {
   return updateScoutPhonePreparation(currentDirectory, input);
 }
-async function toggleScoutElectronVoiceCapture(options = {}) {
+async function toggleScoutDesktopVoiceCapture(options = {}) {
   if (!options.voice?.toggleVoiceCapture) {
     throw new Error("Scout voice capture is unavailable.");
   }
   await options.voice.toggleVoiceCapture();
-  return refreshScoutElectronShellState(options);
+  return refreshScoutDesktopShellState(options);
 }
-async function setScoutElectronVoiceRepliesEnabled(enabled, options = {}) {
+async function setScoutDesktopVoiceRepliesEnabled(enabled, options = {}) {
   if (!options.voice?.setVoiceRepliesEnabled) {
     throw new Error("Scout voice playback control is unavailable.");
   }
   await options.voice.setVoiceRepliesEnabled(enabled);
-  return refreshScoutElectronShellState(options);
+  return refreshScoutDesktopShellState(options);
 }
 
 // apps/desktop/src/app/host/scout-host-services.ts
@@ -14606,7 +14616,7 @@ function resolveCurrentDirectory3(input) {
 function createAppInfoServices(input = {}) {
   const appInfo = input.appInfo;
   return {
-    getAppInfo: () => appInfo ?? getScoutElectronAppInfo()
+    getAppInfo: () => appInfo ?? getScoutDesktopAppInfo()
   };
 }
 function createDesktopStateServices(input = {}) {
@@ -14614,13 +14624,13 @@ function createDesktopStateServices(input = {}) {
   const appInfo = input.appInfo;
   const voice = input.voice;
   return {
-    getServicesState: () => getScoutElectronServicesState({ currentDirectory, appInfo, voice }),
-    getHomeState: () => getScoutElectronHomeState({ currentDirectory, appInfo, voice }),
-    getMessagesWorkspaceState: () => getScoutElectronMessagesWorkspaceState({ currentDirectory, appInfo, voice }),
-    getRelayShellPatch: () => getScoutElectronRelayShellPatch({ currentDirectory, appInfo, voice }),
-    getShellState: () => getScoutElectronShellState({ currentDirectory, appInfo, voice }),
-    refreshRelayShellPatch: () => refreshScoutElectronRelayShellPatch({ currentDirectory, appInfo, voice }),
-    refreshShellState: () => refreshScoutElectronShellState({ currentDirectory, appInfo, voice })
+    getServicesState: () => getScoutDesktopServicesState({ currentDirectory, appInfo, voice }),
+    getHomeState: () => getScoutDesktopHomeState({ currentDirectory, appInfo, voice }),
+    getMessagesWorkspaceState: () => getScoutDesktopMessagesWorkspaceState({ currentDirectory, appInfo, voice }),
+    getRelayShellPatch: () => getScoutDesktopRelayShellPatch({ currentDirectory, appInfo, voice }),
+    getShellState: () => getScoutDesktopShellState({ currentDirectory, appInfo, voice }),
+    refreshRelayShellPatch: () => refreshScoutDesktopRelayShellPatch({ currentDirectory, appInfo, voice }),
+    refreshShellState: () => refreshScoutDesktopShellState({ currentDirectory, appInfo, voice })
   };
 }
 function createSettingsAdminServices(input = {}) {
@@ -14628,38 +14638,38 @@ function createSettingsAdminServices(input = {}) {
   const appInfo = input.appInfo;
   const settings = input.settings ?? {};
   return {
-    getAppSettings: () => getScoutElectronAppSettings(currentDirectory, settings),
-    refreshSettingsInventory: () => refreshScoutElectronAppSettingsInventory(currentDirectory, settings),
-    updateAppSettings: (nextInput) => updateScoutElectronAppSettings(nextInput, currentDirectory, settings),
-    retireProject: (projectRoot) => retireScoutElectronProject(projectRoot, currentDirectory, settings),
-    restoreProject: (projectRoot) => restoreScoutElectronProject(projectRoot, currentDirectory, settings),
-    runOnboardingCommand: (nextInput) => runScoutElectronOnboardingCommand(nextInput, currentDirectory),
-    skipOnboarding: () => skipScoutElectronOnboarding(currentDirectory, settings),
-    restartOnboarding: () => restartScoutElectronOnboarding(currentDirectory, settings),
-    getAgentConfig: (agentId) => getScoutElectronAgentConfig(agentId),
-    updateAgentConfig: (nextInput) => updateScoutElectronAgentConfig(nextInput),
-    createAgent: (nextInput) => createScoutElectronAgent(nextInput, { currentDirectory, appInfo }),
-    getPhonePreparation: () => getScoutElectronPhonePreparation(currentDirectory),
-    updatePhonePreparation: (nextInput) => updateScoutElectronPhonePreparation(nextInput, currentDirectory)
+    getAppSettings: () => getScoutDesktopAppSettings(currentDirectory, settings),
+    refreshSettingsInventory: () => refreshScoutDesktopAppSettingsInventory(currentDirectory, settings),
+    updateAppSettings: (nextInput) => updateScoutDesktopAppSettings(nextInput, currentDirectory, settings),
+    retireProject: (projectRoot) => retireScoutDesktopProject(projectRoot, currentDirectory, settings),
+    restoreProject: (projectRoot) => restoreScoutDesktopProject(projectRoot, currentDirectory, settings),
+    runOnboardingCommand: (nextInput) => runScoutDesktopOnboardingCommand(nextInput, currentDirectory),
+    skipOnboarding: () => skipScoutDesktopOnboarding(currentDirectory, settings),
+    restartOnboarding: () => restartScoutDesktopOnboarding(currentDirectory, settings),
+    getAgentConfig: (agentId) => getScoutDesktopAgentConfig(agentId),
+    updateAgentConfig: (nextInput) => updateScoutDesktopAgentConfig(nextInput),
+    createAgent: (nextInput) => createScoutDesktopAgent(nextInput, { currentDirectory, appInfo }),
+    getPhonePreparation: () => getScoutDesktopPhonePreparation(currentDirectory),
+    updatePhonePreparation: (nextInput) => updateScoutDesktopPhonePreparation(nextInput, currentDirectory)
   };
 }
 function createNativeHostServices(input = {}) {
   const host = input.host ?? {};
   return {
-    pickDirectory: () => pickScoutElectronDirectory(host),
-    reloadApp: () => reloadScoutElectronApp(host),
-    quitApp: () => quitScoutElectronApp(host),
-    revealPath: (filePath) => revealScoutElectronPath(filePath, host)
+    pickDirectory: () => pickScoutHostDirectory(host),
+    reloadApp: () => reloadScoutHostApp(host),
+    quitApp: () => quitScoutHostApp(host),
+    revealPath: (filePath) => revealScoutHostPath(filePath, host)
   };
 }
 function createPairingServices(input = {}) {
   const currentDirectory = resolveCurrentDirectory3(input.currentDirectory);
   return {
-    getPairingState: () => getScoutElectronPairingState(currentDirectory),
-    refreshPairingState: () => refreshScoutElectronPairingState(currentDirectory),
-    controlPairingService: (action) => controlScoutElectronPairingService(action, currentDirectory),
-    updatePairingConfig: (nextInput) => updateScoutElectronPairingConfig(nextInput, currentDirectory),
-    decidePairingApproval: (nextInput) => decideScoutElectronPairingApproval(nextInput, currentDirectory)
+    getPairingState: () => getScoutDesktopPairingState(currentDirectory),
+    refreshPairingState: () => refreshScoutDesktopPairingState(currentDirectory),
+    controlPairingService: (action) => controlScoutDesktopPairingService(action, currentDirectory),
+    updatePairingConfig: (nextInput) => updateScoutDesktopPairingConfig(nextInput, currentDirectory),
+    decidePairingApproval: (nextInput) => decideScoutDesktopPairingApproval(nextInput, currentDirectory)
   };
 }
 function createRelayActivityServices(input = {}) {
@@ -14669,17 +14679,17 @@ function createRelayActivityServices(input = {}) {
   const agentSessionHost = input.agentSessionHost;
   return {
     restartAgent: async (nextInput) => {
-      await restartScoutElectronAgent(nextInput, { currentDirectory, appInfo });
-      return refreshScoutElectronShellState({ currentDirectory, appInfo, voice });
+      await restartScoutDesktopAgent(nextInput, { currentDirectory, appInfo });
+      return refreshScoutDesktopShellState({ currentDirectory, appInfo, voice });
     },
-    sendRelayMessage: (nextInput) => sendScoutElectronRelayMessage(nextInput, { currentDirectory, appInfo }),
+    sendRelayMessage: (nextInput) => sendScoutDesktopRelayMessage(nextInput, { currentDirectory, appInfo }),
     getKeepAliveState: () => getScoutKeepAliveState(),
     acquireKeepAliveLease: (nextInput) => acquireScoutKeepAliveLease(nextInput),
     releaseKeepAliveLease: (nextInput) => releaseScoutKeepAliveLease(nextInput.leaseId),
-    getAgentSession: (agentId) => getScoutElectronAgentSession(agentId),
-    openAgentSession: (agentId) => openScoutElectronAgentSession(agentId, agentSessionHost),
-    toggleVoiceCapture: () => toggleScoutElectronVoiceCapture({ currentDirectory, appInfo, voice }),
-    setVoiceRepliesEnabled: (enabled) => setScoutElectronVoiceRepliesEnabled(enabled, { currentDirectory, appInfo, voice })
+    getAgentSession: (agentId) => getScoutDesktopAgentSession(agentId),
+    openAgentSession: (agentId) => openScoutDesktopAgentSession(agentId, agentSessionHost),
+    toggleVoiceCapture: () => toggleScoutDesktopVoiceCapture({ currentDirectory, appInfo, voice }),
+    setVoiceRepliesEnabled: (enabled) => setScoutDesktopVoiceRepliesEnabled(enabled, { currentDirectory, appInfo, voice })
   };
 }
 function createBrokerAdminServices(input = {}) {
@@ -14689,25 +14699,25 @@ function createBrokerAdminServices(input = {}) {
   const settings = input.settings ?? {};
   return {
     controlBroker: async (action) => {
-      await controlScoutElectronBroker(action, {
+      await controlScoutDesktopBroker(action, {
         currentDirectory,
         appInfo,
         telegram: {
           refreshConfiguration: settings.refreshTelegramConfiguration
         }
       });
-      return refreshScoutElectronShellState({ currentDirectory, appInfo, voice });
+      return refreshScoutDesktopShellState({ currentDirectory, appInfo, voice });
     }
   };
 }
 function createDiagnosticsServices(input = {}) {
   const currentDirectory = resolveCurrentDirectory3(input.currentDirectory);
   return {
-    getLogCatalog: () => getScoutElectronLogCatalog(currentDirectory),
-    getBrokerInspector: () => getScoutElectronBrokerInspector(),
-    getFeedbackBundle: () => getScoutElectronFeedbackBundle(currentDirectory),
-    submitFeedbackReport: (nextInput) => submitScoutElectronFeedbackReport(nextInput, currentDirectory),
-    readLogSource: (nextInput) => readScoutElectronLogSource(nextInput, currentDirectory)
+    getLogCatalog: () => getScoutDesktopLogCatalog(currentDirectory),
+    getBrokerInspector: () => getScoutDesktopBrokerInspector(),
+    getFeedbackBundle: () => getScoutDesktopFeedbackBundle(currentDirectory),
+    submitFeedbackReport: (nextInput) => submitScoutDesktopFeedbackReport(nextInput, currentDirectory),
+    readLogSource: (nextInput) => readScoutDesktopLogSource(nextInput, currentDirectory)
   };
 }
 function createScoutHostServices(input = {}) {
@@ -15695,7 +15705,7 @@ function registerScoutWebAssets(app, options) {
 
 // apps/desktop/src/server/create-scout-web-server.ts
 function defaultMonorepoStaticClientRoot(moduleUrl = import.meta.url) {
-  return resolve7(dirname9(fileURLToPath7(moduleUrl)), "../../../../packages/electron-app/dist/client");
+  return resolve7(dirname9(fileURLToPath7(moduleUrl)), "../../dist/client");
 }
 function parseOptionalPositiveInt(value, fallback) {
   if (typeof value !== "string" || value.trim().length === 0) {