Fix mobile sidebar reset after theme switch

The desktop app uses the paseo:// custom protocol scheme, but the
origin was only passed via PASEO_CORS_ORIGINS when the desktop started
the daemon itself. If the daemon was started by the CLI, the origin
was missing and the Electron renderer's WebSocket connection was
rejected.

Also removes file:// and null from allowed origins — any page loaded
via file:// could connect to the daemon, which is a security gap.

.github/workflows/deploy-website.yml

@@ -9,8 +9,6 @@ on:
       - 'package-lock.json'
       - 'patches/**'
       - '.github/workflows/deploy-website.yml'
-  release:
-    types: [published, edited]
   workflow_dispatch:
 
 jobs:

CHANGELOG.md

@@ -1,15 +1,5 @@
 # Changelog
 
-## 0.1.37 - 2026-03-29
-
-### Added
-- Custom window controls on Windows and Linux — the native titlebar is replaced with overlay controls that match the app's design.
-- Desktop file logging with electron-log for easier debugging of daemon and app issues.
-
-### Fixed
-- Fixed broken PATH propagation and Claude binary resolution on Windows.
-- Dictation errors now show a visible toast instead of failing silently.
-
 ## 0.1.36 - 2026-03-27
 
 ### Fixed

README.md

@@ -26,32 +26,20 @@ Run agents in parallel on your own machines. Ship from your phone or your desk.
 
 ## Getting Started
 
-Paseo runs a local server called the daemon that manages your coding agents. Clients like the desktop app, mobile app, web app, and CLI connect to it.
+### Desktop app
 
-### Prerequisites
+Download from [paseo.sh/download](https://paseo.sh/download) or the [GitHub releases page](https://github.com/getpaseo/paseo/releases). The app bundles its own daemon, so there's nothing else to install. It can also connect to daemons running on other machines.
 
-You need at least one agent CLI installed and configured with your credentials:
+### Headless / server mode
 
-- [Claude Code](https://docs.anthropic.com/en/docs/claude-code)
-- [Codex](https://github.com/openai/codex)
-- [OpenCode](https://github.com/anomalyco/opencode)
-
-### Desktop app (recommended)
-
-Download it from [paseo.sh/download](https://paseo.sh/download) or the [GitHub releases page](https://github.com/getpaseo/paseo/releases). Open the app and the daemon starts automatically. Nothing else to install.
-
-To connect from your phone, scan the QR code shown in Settings.
-
-### CLI / headless
-
-Install the CLI and start Paseo:
+Run the daemon on any machine:
 
 ```bash
 npm install -g @getpaseo/cli
 paseo
 ```
 
-This shows a QR code in the terminal. Connect from any client. This path is useful for servers and remote machines.
+Then connect from any client — desktop, web, mobile, or CLI. See [paseo.sh/download](https://paseo.sh/download) for all options.
 
 For full setup and configuration, see:
 - [Docs](https://paseo.sh/docs)

docs/ARCHITECTURE.md

@@ -31,14 +31,6 @@ Your code never leaves your machine. Paseo is local-first.
 └───────────┘ └────────┘ └──────────┘
 ```
 
-## Components at a glance
-
-- **Daemon:** Local server that spawns and manages agent processes and exposes the WebSocket API.
-- **App:** Cross-platform Expo client for iOS, Android, web, and the shared UI used by desktop.
-- **CLI:** Terminal interface for agent workflows that can also start and manage the daemon.
-- **Desktop app:** Electron wrapper around the web app that bundles and auto-manages its own daemon.
-- **Relay:** Optional encrypted bridge for remote access without opening ports directly.
-
 ## Packages
 
 ### `packages/server` — The daemon

nix/package.nix

@@ -42,7 +42,7 @@ buildNpmPackage rec {
 
   # To update: run `nix build` with lib.fakeHash, copy the `got:` hash.
   # CI auto-updates this when package-lock.json changes (see .github/workflows/).
-  npmDepsHash = "sha256-ebbF7pug19PBgJQahUCTlvhcLS/LF8Nv1UIIG31LRmQ=";
+  npmDepsHash = "sha256-jBl1E7cwEf5XKXFQip/ZlEa/zNQoz0Hq5t0hqjp8Qe4=";
 
   # Prevent onnxruntime-node's install script from running during automatic
   # npm rebuild (it tries to download from api.nuget.org, which fails in the sandbox).

package-lock.json

@@ -25126,15 +25126,6 @@
         "node": ">=10"
       }
     },
-    "node_modules/lucide-react": {
-      "version": "1.7.0",
-      "resolved": "https://registry.npmjs.org/lucide-react/-/lucide-react-1.7.0.tgz",
-      "integrity": "sha512-yI7BeItCLZJTXikmK4KNUGCKoGzSvbKlfCvw44bU4fXAL6v3gYS4uHD1jzsLkfwODYwI6Drw5Tu9Z5ulDe0TSg==",
-      "license": "ISC",
-      "peerDependencies": {
-        "react": "^16.5.1 || ^17.0.0 || ^18.0.0 || ^19.0.0"
-      }
-    },
     "node_modules/lucide-react-native": {
       "version": "0.546.0",
       "resolved": "https://registry.npmjs.org/lucide-react-native/-/lucide-react-native-0.546.0.tgz",
@@ -35318,7 +35309,6 @@
         "@deepgram/sdk": "^3.4.0",
         "@getpaseo/highlight": "0.1.37",
         "@getpaseo/relay": "0.1.37",
-        "@isaacs/ttlcache": "^2.1.4",
         "@modelcontextprotocol/sdk": "^1.20.1",
         "@opencode-ai/sdk": "1.2.6",
         "@sctg/sentencepiece-js": "^1.1.0",
@@ -35361,15 +35351,6 @@
         "vitest": "^3.2.4"
       }
     },
-    "packages/server/node_modules/@isaacs/ttlcache": {
-      "version": "2.1.4",
-      "resolved": "https://registry.npmjs.org/@isaacs/ttlcache/-/ttlcache-2.1.4.tgz",
-      "integrity": "sha512-7kMz0BJpMvgAMkyglums7B2vtrn5g0a0am77JY0GjkZZNetOBCFn7AG7gKCwT0QPiXyxW7YIQSgtARknUEOcxQ==",
-      "license": "BlueOak-1.0.0",
-      "engines": {
-        "node": ">=12"
-      }
-    },
     "packages/server/node_modules/@modelcontextprotocol/sdk": {
       "version": "1.20.1",
       "resolved": "https://registry.npmjs.org/@modelcontextprotocol/sdk/-/sdk-1.20.1.tgz",
@@ -35722,7 +35703,6 @@
         "@tanstack/react-router": "^1.120.3",
         "@tanstack/react-start": "^1.120.3",
         "framer-motion": "^12.35.2",
-        "lucide-react": "^1.7.0",
         "react": "^19.1.4",
         "react-dom": "^19.1.4",
         "react-markdown": "^10.1.0",

packages/app/src/app/_layout.tsx

@@ -15,7 +15,7 @@ import { PortalProvider } from "@gorhom/portal";
 import { VoiceProvider } from "@/contexts/voice-context";
 import { useAppSettings } from "@/hooks/use-settings";
 import { useFaviconStatus } from "@/hooks/use-favicon-status";
-import { View, Text } from "react-native";
+import { View, ActivityIndicator, Text } from "react-native";
 import { UnistylesRuntime, useUnistyles } from "react-native-unistyles";
 import { darkTheme } from "@/styles/theme";
 import { QueryClientProvider } from "@tanstack/react-query";
@@ -26,13 +26,12 @@ import {
   useHostRuntimeClient,
 } from "@/runtime/host-runtime";
 import { shouldUseDesktopDaemon } from "@/desktop/daemon/desktop-daemon";
+import { StartupSplashScreen } from "@/screens/startup-splash-screen";
 import { loadSettingsFromStorage } from "@/hooks/use-settings";
-import { useColorScheme } from "@/hooks/use-color-scheme";
 import { SessionProvider } from "@/contexts/session-context";
 import type { HostProfile } from "@/types/host-connection";
 import {
   createContext,
-  useCallback,
   useContext,
   useState,
   useEffect,
@@ -69,7 +68,6 @@ import {
   ensureOsNotificationPermission,
 } from "@/utils/os-notifications";
 import { getDesktopHost } from "@/desktop/host";
-import { setDesktopTitleBarTheme } from "@/desktop/electron/window";
 import { buildNotificationRoute } from "@/utils/notification-routing";
 import {
   buildHostRootRoute,
@@ -81,18 +79,7 @@ import {
 import { syncNavigationActiveWorkspace } from "@/stores/navigation-active-workspace-store";
 
 polyfillCrypto();
-
-export type HostRuntimeBootstrapState = {
-  phase: "starting-daemon" | "connecting" | "online" | "error";
-  error: string | null;
-  retry: () => void;
-};
-
-const HostRuntimeBootstrapContext = createContext<HostRuntimeBootstrapState>({
-  phase: "starting-daemon",
-  error: null,
-  retry: () => {},
-});
+const HostRuntimeBootstrapContext = createContext(false);
 
 function PushNotificationRouter() {
   const router = useRouter();
@@ -220,99 +207,49 @@ function HostSessionManager() {
 }
 
 function HostRuntimeBootstrapProvider({ children }: { children: ReactNode }) {
-  const [phase, setPhase] = useState<HostRuntimeBootstrapState["phase"]>("starting-daemon");
-  const [error, setError] = useState<string | null>(null);
-  const [retryToken, setRetryToken] = useState(0);
-  const retry = useCallback(() => {
-    setPhase("starting-daemon");
-    setError(null);
-    setRetryToken((current) => current + 1);
-  }, []);
+  const [ready, setReady] = useState(false);
 
   useEffect(() => {
     let cancelled = false;
-    const shouldManageDesktop = shouldUseDesktopDaemon();
     const store = getHostRuntimeStore();
 
     const init = async () => {
       const settings = await loadSettingsFromStorage();
-      const isDesktopManaged = shouldManageDesktop && settings.manageBuiltInDaemon;
+      const isDesktopManaged = shouldUseDesktopDaemon() && settings.manageBuiltInDaemon;
       await store.loadFromStorage();
       if (isDesktopManaged) {
-        setPhase("starting-daemon");
-        setError(null);
-        const bootstrapResult = await store.bootstrapDesktop();
-        if (!bootstrapResult.ok) {
-          if (!cancelled) {
-            setPhase("error");
-            setError(bootstrapResult.error);
-          }
-          return;
-        }
-
-        if (cancelled) {
-          return;
-        }
-
-        setPhase("connecting");
-        await store.addConnectionFromListenAndWaitForOnline({
-          listenAddress: bootstrapResult.listenAddress,
-          serverId: bootstrapResult.serverId,
-          hostname: bootstrapResult.hostname,
-        });
-        if (!cancelled) {
-          setPhase("online");
-          setError(null);
-        }
+        await store.bootstrap({ manageBuiltInDaemon: true });
       } else {
         void store.bootstrap({ manageBuiltInDaemon: settings.manageBuiltInDaemon });
-        if (!cancelled) {
-          setPhase("online");
-          setError(null);
-        }
       }
     };
 
-    void init().catch((bootstrapError) => {
-      console.error("[HostRuntime] Failed to initialize store", bootstrapError);
-      if (cancelled) {
-        return;
-      }
-      if (shouldManageDesktop) {
-        setPhase("error");
-        setError(bootstrapError instanceof Error ? bootstrapError.message : String(bootstrapError));
-        return;
-      }
-      setPhase("online");
-      setError(null);
-    });
+    void init()
+      .then(() => {
+        if (!cancelled) {
+          setReady(true);
+        }
+      })
+      .catch((error) => {
+        console.error("[HostRuntime] Failed to initialize store", error);
+        if (!cancelled) {
+          setReady(true);
+        }
+      });
 
     return () => {
       cancelled = true;
     };
-  }, [retryToken]);
-
-  const state = useMemo<HostRuntimeBootstrapState>(
-    () => ({
-      phase,
-      error,
-      retry,
-    }),
-    [error, phase, retry],
-  );
+  }, []);
 
   return (
-    <HostRuntimeBootstrapContext.Provider value={state}>
+    <HostRuntimeBootstrapContext.Provider value={ready}>
       {children}
     </HostRuntimeBootstrapContext.Provider>
   );
 }
 
-export function useStoreReady(): boolean {
-  return useContext(HostRuntimeBootstrapContext).phase === "online";
-}
-
-export function useHostRuntimeBootstrapState(): HostRuntimeBootstrapState {
+function useStoreReady(): boolean {
   return useContext(HostRuntimeBootstrapContext);
 }
 
@@ -473,30 +410,26 @@ function MobileGestureWrapper({
 
 function ProvidersWrapper({ children }: { children: ReactNode }) {
   const { settings, isLoading: settingsLoading } = useAppSettings();
+  const storeReady = useStoreReady();
   const { upsertConnectionFromOfferUrl } = useHostMutations();
-  const systemColorScheme = useColorScheme();
-  const resolvedTheme = settings.theme === "auto" ? (systemColorScheme ?? "light") : settings.theme;
+  const isLoading = settingsLoading || !storeReady;
 
   // Apply theme setting on mount and when it changes
   useEffect(() => {
-    if (settingsLoading) return;
+    if (isLoading) return;
     if (settings.theme === "auto") {
       UnistylesRuntime.setAdaptiveThemes(true);
     } else {
       UnistylesRuntime.setAdaptiveThemes(false);
       UnistylesRuntime.setTheme(settings.theme);
     }
-  }, [settingsLoading, settings.theme]);
+  }, [isLoading, settings.theme]);
 
-  useEffect(() => {
-    if (settingsLoading || Platform.OS !== "web") {
-      return;
-    }
-
-    void setDesktopTitleBarTheme(resolvedTheme).catch((error) => {
-      console.warn("[DesktopWindow] Failed to update title bar theme", error);
-    });
-  }, [settingsLoading, resolvedTheme]);
+  if (isLoading) {
+    const isDesktopManaged =
+      !settingsLoading && shouldUseDesktopDaemon() && settings.manageBuiltInDaemon;
+    return isDesktopManaged ? <StartupSplashScreen /> : <LoadingView />;
+  }
 
   return (
     <VoiceProvider>
@@ -599,38 +532,6 @@ function FaviconStatusSync() {
   return null;
 }
 
-function RootStack() {
-  const storeReady = useStoreReady();
-
-  return (
-    <Stack
-      screenOptions={{
-        headerShown: false,
-        animation: "none",
-        contentStyle: {
-          backgroundColor: darkTheme.colors.surface0,
-        },
-      }}
-    >
-      <Stack.Protected guard={storeReady}>
-        <Stack.Screen name="welcome" />
-        <Stack.Screen name="settings" />
-        <Stack.Screen name="h/[serverId]/workspace/[workspaceId]" />
-        <Stack.Screen
-          name="h/[serverId]/agent/[agentId]"
-          options={{ gestureEnabled: false }}
-        />
-        <Stack.Screen name="h/[serverId]/index" />
-        <Stack.Screen name="h/[serverId]/sessions" />
-        <Stack.Screen name="h/[serverId]/open-project" />
-        <Stack.Screen name="h/[serverId]/settings" />
-        <Stack.Screen name="pair-scan" />
-      </Stack.Protected>
-      <Stack.Screen name="index" />
-    </Stack>
-  );
-}
-
 function NavigationActiveWorkspaceObserver() {
   const navigationRef = useNavigationContainerRef();
 
@@ -651,6 +552,57 @@ function NavigationActiveWorkspaceObserver() {
   return null;
 }
 
+function LoadingView({ message }: { message?: string } = {}) {
+  return (
+    <View
+      style={{
+        flex: 1,
+        justifyContent: "center",
+        alignItems: "center",
+        backgroundColor: darkTheme.colors.surface0,
+      }}
+    >
+      <ActivityIndicator size="large" color={darkTheme.colors.foreground} />
+      {message ? (
+        <Text
+          style={{
+            color: darkTheme.colors.foregroundMuted,
+            marginTop: 16,
+            fontSize: 14,
+          }}
+        >
+          {message}
+        </Text>
+      ) : null}
+    </View>
+  );
+}
+
+function MissingDaemonView() {
+  return (
+    <View
+      style={{
+        flex: 1,
+        justifyContent: "center",
+        alignItems: "center",
+        padding: 24,
+        backgroundColor: darkTheme.colors.surface0,
+      }}
+    >
+      <ActivityIndicator size="small" color={darkTheme.colors.foreground} />
+      <Text
+        style={{
+          color: darkTheme.colors.foreground,
+          marginTop: 16,
+          textAlign: "center",
+        }}
+      >
+        No host configured. Open Settings to add a server URL.
+      </Text>
+    </View>
+  );
+}
+
 export default function RootLayout() {
   return (
     <GestureHandlerRootView style={{ flex: 1, backgroundColor: darkTheme.colors.surface0 }}>
@@ -667,7 +619,28 @@ export default function RootLayout() {
                       <HorizontalScrollProvider>
                         <ToastProvider>
                           <AppWithSidebar>
-                            <RootStack />
+                            <Stack
+                              screenOptions={{
+                                headerShown: false,
+                                animation: "none",
+                                contentStyle: {
+                                  backgroundColor: darkTheme.colors.surface0,
+                                },
+                              }}
+                            >
+                              <Stack.Screen name="index" />
+                              <Stack.Screen name="settings" />
+                              <Stack.Screen name="h/[serverId]/workspace/[workspaceId]" />
+                              <Stack.Screen
+                                name="h/[serverId]/agent/[agentId]"
+                                options={{ gestureEnabled: false }}
+                              />
+                              <Stack.Screen name="h/[serverId]/index" />
+                              <Stack.Screen name="h/[serverId]/sessions" />
+                              <Stack.Screen name="h/[serverId]/open-project" />
+                              <Stack.Screen name="h/[serverId]/settings" />
+                              <Stack.Screen name="pair-scan" />
+                            </Stack>
                           </AppWithSidebar>
                         </ToastProvider>
                       </HorizontalScrollProvider>

packages/app/src/app/index.tsx

@@ -1,65 +1,18 @@
-import { useEffect, useSyncExternalStore } from "react";
+import { useEffect } from "react";
 import { usePathname, useRouter } from "expo-router";
-import { StartupSplashScreen } from "@/screens/startup-splash-screen";
-import {
-  useHostRuntimeBootstrapState,
-  useStoreReady,
-} from "@/app/_layout";
-import {
-  getHostRuntimeStore,
-  isHostRuntimeConnected,
-  useHosts,
-} from "@/runtime/host-runtime";
-import { buildHostRootRoute } from "@/utils/host-routes";
 
 const WELCOME_ROUTE = "/welcome";
 
-function useAnyOnlineHostServerId(serverIds: string[]): string | null {
-  const runtime = getHostRuntimeStore();
-
-  return useSyncExternalStore(
-    (onStoreChange) => runtime.subscribeAll(onStoreChange),
-    () => {
-      let firstOnlineServerId: string | null = null;
-      let firstOnlineAt: string | null = null;
-      for (const serverId of serverIds) {
-        const snapshot = runtime.getSnapshot(serverId);
-        const lastOnlineAt = snapshot?.lastOnlineAt ?? null;
-        if (!isHostRuntimeConnected(snapshot) || !lastOnlineAt) {
-          continue;
-        }
-        if (!firstOnlineAt || lastOnlineAt < firstOnlineAt) {
-          firstOnlineAt = lastOnlineAt;
-          firstOnlineServerId = serverId;
-        }
-      }
-      return firstOnlineServerId;
-    },
-    () => null,
-  );
-}
-
 export default function Index() {
   const router = useRouter();
   const pathname = usePathname();
-  const bootstrapState = useHostRuntimeBootstrapState();
-  const storeReady = useStoreReady();
-  const hosts = useHosts();
-  const anyOnlineServerId = useAnyOnlineHostServerId(hosts.map((host) => host.serverId));
 
   useEffect(() => {
-    if (!storeReady) {
-      return;
-    }
     if (pathname !== "/" && pathname !== "") {
       return;
     }
+    router.replace(WELCOME_ROUTE as any);
+  }, [pathname, router]);
 
-    const targetRoute = anyOnlineServerId
-      ? buildHostRootRoute(anyOnlineServerId)
-      : WELCOME_ROUTE;
-    router.replace(targetRoute as any);
-  }, [anyOnlineServerId, pathname, router, storeReady]);
-
-  return <StartupSplashScreen bootstrapState={bootstrapState} />;
+  return null;
 }

packages/app/src/components/agent-status-bar.tsx

@@ -8,7 +8,6 @@ import { getProviderIcon } from "@/components/provider-icons";
 import { CombinedModelSelector } from "@/components/combined-model-selector";
 import { useQuery } from "@tanstack/react-query";
 import { useSessionStore } from "@/stores/session-store";
-import { mergeProviderPreferences, useFormPreferences } from "@/hooks/use-form-preferences";
 import {
   DropdownMenu,
   DropdownMenuContent,
@@ -610,7 +609,6 @@ function ControlledStatusBar({
 const EMPTY_MODES: AgentMode[] = [];
 
 export function AgentStatusBar({ agentId, serverId }: AgentStatusBarProps) {
-  const { preferences, updatePreferences } = useFormPreferences();
   const agent = useSessionStore(
     useShallow((state) => {
       const currentAgent = state.sessions[serverId]?.agents?.get(agentId) ?? null;
@@ -711,17 +709,6 @@ export function AgentStatusBar({ agentId, serverId }: AgentStatusBarProps) {
         if (!client) {
           return;
         }
-        void updatePreferences(
-          mergeProviderPreferences({
-            preferences,
-            provider: agent.provider,
-            updates: {
-              model: modelId,
-            },
-          }),
-        ).catch((error) => {
-          console.warn("[AgentStatusBar] persist model preference failed", error);
-        });
         void client.setAgentModel(agentId, modelId).catch((error) => {
           console.warn("[AgentStatusBar] setAgentModel failed", error);
         });
@@ -732,23 +719,6 @@ export function AgentStatusBar({ agentId, serverId }: AgentStatusBarProps) {
         if (!client) {
           return;
         }
-        const activeModelId = modelSelection.activeModelId;
-        if (activeModelId) {
-          void updatePreferences(
-            mergeProviderPreferences({
-              preferences,
-              provider: agent.provider,
-              updates: {
-                model: activeModelId,
-                thinkingByModel: {
-                  [activeModelId]: thinkingOptionId,
-                },
-              },
-            }),
-          ).catch((error) => {
-            console.warn("[AgentStatusBar] persist thinking preference failed", error);
-          });
-        }
         void client.setAgentThinkingOption(agentId, thinkingOptionId).catch((error) => {
           console.warn("[AgentStatusBar] setAgentThinkingOption failed", error);
         });

packages/app/src/components/headers/menu-header.tsx

@@ -10,7 +10,6 @@ import { getShortcutOs } from "@/utils/shortcut-platform";
 interface MenuHeaderProps {
   title?: string;
   rightContent?: ReactNode;
-  borderless?: boolean;
 }
 
 interface SidebarMenuToggleProps {
@@ -76,7 +75,7 @@ export function SidebarMenuToggle({
   );
 }
 
-export function MenuHeader({ title, rightContent, borderless }: MenuHeaderProps) {
+export function MenuHeader({ title, rightContent }: MenuHeaderProps) {
   return (
     <ScreenHeader
       left={
@@ -91,7 +90,6 @@ export function MenuHeader({ title, rightContent, borderless }: MenuHeaderProps)
       }
       right={rightContent}
       leftStyle={styles.left}
-      borderless={borderless}
     />
   );
 }

packages/app/src/components/headers/screen-header.tsx

@@ -15,14 +15,13 @@ interface ScreenHeaderProps {
   right?: ReactNode;
   leftStyle?: StyleProp<ViewStyle>;
   rightStyle?: StyleProp<ViewStyle>;
-  borderless?: boolean;
 }
 
 /**
  * Shared frame for the home/back headers so we only maintain padding, border,
  * and safe-area logic in one place.
  */
-export function ScreenHeader({ left, right, leftStyle, rightStyle, borderless }: ScreenHeaderProps) {
+export function ScreenHeader({ left, right, leftStyle, rightStyle }: ScreenHeaderProps) {
   const { theme } = useUnistyles();
   const insets = useSafeAreaInsets();
   const isMobile = UnistylesRuntime.breakpoint === "xs" || UnistylesRuntime.breakpoint === "sm";
@@ -48,7 +47,6 @@ export function ScreenHeader({ left, right, leftStyle, rightStyle, borderless }:
               paddingLeft: baseHorizontalPadding + collapsedSidebarInset.left,
               paddingRight: baseHorizontalPadding + collapsedSidebarInset.right,
             },
-            borderless && styles.borderless,
           ]}
           {...dragHandlers}
         >
@@ -89,7 +87,4 @@ const styles = StyleSheet.create((theme) => ({
     alignItems: "center",
     gap: theme.spacing[2],
   },
-  borderless: {
-    borderBottomWidth: 0,
-  },
 }));

packages/app/src/components/left-sidebar.tsx

@@ -520,7 +520,6 @@ function MobileSidebar({
                 isRefreshing={isManualRefresh && isRevalidating}
                 onRefresh={handleRefresh}
                 onWorkspacePress={closeToAgent}
-                onAddProject={handleOpenProject}
                 parentGestureRef={closeGestureRef}
               />
             )}
@@ -557,7 +556,7 @@ function MobileSidebar({
                     >
                       {({ hovered }) => (
                         <Plus
-                          size={theme.iconSize.md}
+                          size={theme.iconSize.lg}
                           color={hovered ? theme.colors.foreground : theme.colors.foregroundMuted}
                         />
                       )}
@@ -582,7 +581,7 @@ function MobileSidebar({
                 >
                   {({ hovered }) => (
                     <Settings
-                      size={theme.iconSize.md}
+                      size={theme.iconSize.lg}
                       color={hovered ? theme.colors.foreground : theme.colors.foregroundMuted}
                     />
                   )}
@@ -702,7 +701,6 @@ function DesktopSidebar({
           projects={projects}
           isRefreshing={isManualRefresh && isRevalidating}
           onRefresh={handleRefresh}
-          onAddProject={handleOpenProject}
         />
       )}
 
@@ -738,7 +736,7 @@ function DesktopSidebar({
               >
                 {({ hovered }) => (
                   <Plus
-                    size={theme.iconSize.md}
+                    size={theme.iconSize.lg}
                     color={hovered ? theme.colors.foreground : theme.colors.foregroundMuted}
                   />
                 )}
@@ -763,7 +761,7 @@ function DesktopSidebar({
           >
             {({ hovered }) => (
               <Settings
-                size={theme.iconSize.md}
+                size={theme.iconSize.lg}
                 color={hovered ? theme.colors.foreground : theme.colors.foregroundMuted}
               />
             )}

packages/app/src/components/sidebar-workspace-list.tsx

@@ -36,7 +36,6 @@ import {
   GitPullRequest,
   Monitor,
   MoreVertical,
-  Plus,
 } from "lucide-react-native";
 import { NestableScrollContainer } from "react-native-draggable-flatlist";
 import { DraggableList, type DraggableRenderItemInfo } from "./draggable-list";
@@ -74,7 +73,6 @@ import { confirmDialog } from "@/utils/confirm-dialog";
 import { projectIconPlaceholderLabelFromDisplayName } from "@/utils/project-display-name";
 import { shouldRenderSyncedStatusLoader } from "@/utils/status-loader";
 import { getStatusDotColor } from "@/utils/status-dot-color";
-import { Button } from "@/components/ui/button";
 import { Tooltip, TooltipContent, TooltipTrigger } from "@/components/ui/tooltip";
 import { Shortcut } from "@/components/ui/shortcut";
 import type { ShortcutKey } from "@/utils/format-shortcut";
@@ -115,7 +113,6 @@ interface SidebarWorkspaceListProps {
   isRefreshing?: boolean;
   onRefresh?: () => void;
   onWorkspacePress?: () => void;
-  onAddProject?: () => void;
   listFooterComponent?: ReactElement | null;
   /** Gesture ref for coordinating with parent gestures (e.g., sidebar close) */
   parentGestureRef?: MutableRefObject<GestureType | undefined>;
@@ -1634,7 +1631,6 @@ export function SidebarWorkspaceList({
   isRefreshing = false,
   onRefresh,
   onWorkspacePress,
-  onAddProject,
   listFooterComponent,
   parentGestureRef,
 }: SidebarWorkspaceListProps) {
@@ -1904,18 +1900,7 @@ export function SidebarWorkspaceList({
   const content = (
     <>
       {projects.length === 0 ? (
-        <View style={styles.emptyContainer}>
-          <Text style={styles.emptyTitle}>No projects yet</Text>
-          <Text style={styles.emptyText}>Add a project to get started</Text>
-          <Button
-            variant="ghost"
-            size="sm"
-            leftIcon={Plus}
-            onPress={onAddProject}
-          >
-            Add project
-          </Button>
-        </View>
+        <Text style={styles.emptyText}>No projects yet</Text>
       ) : (
         <DraggableList
           testID="sidebar-project-list"
@@ -1978,27 +1963,11 @@ const styles = StyleSheet.create((theme) => ({
     marginBottom: theme.spacing[1],
   },
   workspaceListContainer: {},
-  emptyContainer: {
-    marginHorizontal: theme.spacing[2],
-    marginTop: theme.spacing[4],
-    paddingTop: theme.spacing[6],
-    paddingBottom: theme.spacing[4],
-    paddingHorizontal: theme.spacing[4],
-    borderRadius: theme.borderRadius.lg,
-    backgroundColor: theme.colors.surface0,
-    alignItems: "center",
-    gap: theme.spacing[3],
-  },
-  emptyTitle: {
-    color: theme.colors.foreground,
-    fontSize: theme.fontSize.sm,
-    fontWeight: theme.fontWeight.medium,
-    textAlign: "center",
-  },
   emptyText: {
     color: theme.colors.foregroundMuted,
-    fontSize: theme.fontSize.sm,
     textAlign: "center",
+    marginTop: theme.spacing[8],
+    marginHorizontal: theme.spacing[2],
   },
   projectRow: {
     minHeight: 36,

packages/app/src/components/terminal-emulator.tsx

@@ -565,18 +565,6 @@ export default function TerminalEmulator({
   const handleInsetTop = Math.max(0, (thumbRegionHeight - scrollbarGeometry.handleSize) / 2);
   const handleTravelDurationMs =
     isDraggingScrollbar || isScrollActive ? 0 : SCROLLBAR_HANDLE_TRAVEL_DURATION_MS;
-  const handleContextMenu = () => {
-    const showContextMenu = window.paseoDesktop?.menu?.showContextMenu;
-    if (typeof showContextMenu !== "function") {
-      return;
-    }
-
-    const hasSelection = Boolean(window.getSelection()?.toString());
-    void showContextMenu({
-      kind: "terminal",
-      hasSelection,
-    });
-  };
 
   return (
     <div
@@ -598,10 +586,6 @@ export default function TerminalEmulator({
       onPointerDown={() => {
         runtimeRef.current?.focus();
       }}
-      onContextMenu={(event) => {
-        event.preventDefault();
-        handleContextMenu();
-      }}
     >
       <div
         ref={hostRef}

packages/app/src/components/ui/button.tsx

@@ -1,19 +1,11 @@
-import { useState, type ComponentType, type PropsWithChildren, type ReactElement } from "react";
+import type { PropsWithChildren, ReactElement } from "react";
 import { Pressable, Text, View } from "react-native";
 import type { PressableProps, StyleProp, TextStyle, ViewStyle } from "react-native";
-import { StyleSheet, useUnistyles } from "react-native-unistyles";
+import { StyleSheet } from "react-native-unistyles";
 
 type ButtonVariant = "default" | "secondary" | "outline" | "ghost" | "destructive";
 type ButtonSize = "sm" | "md" | "lg";
 
-type LeftIcon =
-  | ReactElement
-  | ComponentType<{ color: string; size: number }>
-  | ((color: string) => ReactElement)
-  | null;
-
-const ICON_SIZE: Record<ButtonSize, number> = { sm: 14, md: 16, lg: 20 };
-
 const styles = StyleSheet.create((theme) => ({
   base: {
     flexDirection: "row",
@@ -75,12 +67,6 @@ const styles = StyleSheet.create((theme) => ({
   textDestructive: {
     color: theme.colors.palette.white,
   },
-  textGhost: {
-    color: theme.colors.foregroundMuted,
-  },
-  textGhostHovered: {
-    color: theme.colors.foreground,
-  },
 }));
 
 export function Button({
@@ -97,14 +83,11 @@ export function Button({
   Omit<PressableProps, "style"> & {
     variant?: ButtonVariant;
     size?: ButtonSize;
-    leftIcon?: LeftIcon;
+    leftIcon?: ReactElement | null;
     style?: StyleProp<ViewStyle>;
     textStyle?: StyleProp<TextStyle>;
   }
 >) {
-  const [hovered, setHovered] = useState(false);
-  const { theme } = useUnistyles();
-
   const variantStyle =
     variant === "default"
       ? styles.default
@@ -117,47 +100,19 @@ export function Button({
             : styles.destructive;
 
   const sizeStyle = size === "sm" ? styles.sm : size === "lg" ? styles.lg : styles.md;
-  const isGhostHovered = hovered && variant === "ghost";
 
   const resolvedTextStyle = [
     styles.text,
     variant === "default" ? styles.textDefault : null,
     variant === "destructive" ? styles.textDestructive : null,
-    variant === "ghost" ? styles.textGhost : null,
     textStyle,
-    isGhostHovered ? styles.textGhostHovered : null,
   ];
 
-  function renderIcon() {
-    if (!leftIcon) return null;
-
-    // Pre-rendered element — pass through
-    if (typeof leftIcon === "object" && "type" in leftIcon) {
-      return <View>{leftIcon}</View>;
-    }
-
-    const color = variant === "ghost"
-      ? (isGhostHovered ? theme.colors.foreground : theme.colors.foregroundMuted)
-      : theme.colors.foreground;
-    const iconSize = ICON_SIZE[size];
-
-    // Render function
-    if (typeof leftIcon === "function" && !leftIcon.prototype?.isReactComponent && leftIcon.length > 0) {
-      return <View>{(leftIcon as (color: string) => ReactElement)(color)}</View>;
-    }
-
-    // Component type
-    const Icon = leftIcon as ComponentType<{ color: string; size: number }>;
-    return <View><Icon color={color} size={iconSize} /></View>;
-  }
-
   return (
     <Pressable
       {...props}
       accessibilityRole={accessibilityRole ?? "button"}
       disabled={disabled}
-      onHoverIn={() => setHovered(true)}
-      onHoverOut={() => setHovered(false)}
       style={({ pressed }) => [
         styles.base,
         sizeStyle,
@@ -167,7 +122,7 @@ export function Button({
         style,
       ]}
     >
-      {renderIcon()}
+      {leftIcon ? <View>{leftIcon}</View> : null}
       <Text style={resolvedTextStyle}>{children}</Text>
     </Pressable>
   );

packages/app/src/components/ui/dropdown-menu.tsx

@@ -278,10 +278,7 @@ export function DropdownMenuContent({
       setModalVisible(true);
       setClosing(false);
     } else if (modalVisible) {
-      // Avoid leaving an invisible full-screen Modal mounted on native when
-      // the exit animation callback does not fire.
-      setClosing(false);
-      setModalVisible(false);
+      setClosing(true);
     }
   }, [open, modalVisible]);
 

packages/app/src/desktop/electron/window.ts

@@ -27,12 +27,3 @@ export async function isDesktopFullscreen(): Promise<boolean> {
   }
   return await win.isFullscreen();
 }
-
-export async function setDesktopTitleBarTheme(theme: "light" | "dark"): Promise<void> {
-  const win = getDesktopWindow();
-  if (!win || typeof win.setTitleBarTheme !== "function") {
-    return;
-  }
-
-  await win.setTitleBarTheme(theme);
-}

packages/app/src/desktop/host.ts

@@ -37,13 +37,6 @@ export interface DesktopOpenerBridge {
   openUrl?: (url: string) => Promise<void>;
 }
 
-export interface DesktopMenuBridge {
-  showContextMenu?: (input?: {
-    kind?: "terminal";
-    hasSelection?: boolean;
-  }) => Promise<void>;
-}
-
 export interface DesktopWindowBridge {
   label?: string;
   startMove?: (screenX: number, screenY: number) => void;
@@ -51,7 +44,6 @@ export interface DesktopWindowBridge {
   endMove?: () => void;
   toggleMaximize?: () => Promise<void>;
   isFullscreen?: () => Promise<boolean>;
-  setTitleBarTheme?: (theme: "light" | "dark") => Promise<void>;
   onResized?: <TEvent = unknown>(
     handler: (event: TEvent) => void,
   ) => Promise<() => void> | (() => void);
@@ -81,7 +73,6 @@ export interface DesktopHostBridge {
   dialog?: DesktopDialogBridge;
   notification?: DesktopNotificationBridge;
   opener?: DesktopOpenerBridge;
-  menu?: DesktopMenuBridge;
 }
 
 declare global {

packages/app/src/desktop/updates/update-banner.tsx

@@ -10,15 +10,8 @@ const CHANGELOG_URL = "https://paseo.sh/changelog";
 
 export function UpdateBanner() {
   const { theme } = useUnistyles();
-  const {
-    isDesktop,
-    status,
-    availableUpdate,
-    errorMessage,
-    checkForUpdates,
-    installUpdate,
-    isInstalling,
-  } = useDesktopAppUpdater();
+  const { isDesktop, status, availableUpdate, checkForUpdates, installUpdate, isInstalling } =
+    useDesktopAppUpdater();
   const [dismissed, setDismissed] = useState(false);
   const intervalRef = useRef<ReturnType<typeof setInterval> | null>(null);
 
@@ -40,36 +33,24 @@ export function UpdateBanner() {
 
   if (!isDesktop) return null;
   if (dismissed) return null;
-  if (status !== "available" && status !== "installed" && status !== "installing" && status !== "error")
-    return null;
+  if (status !== "available" && status !== "installed") return null;
 
   const isInstalled = status === "installed";
-  const isError = status === "error";
-
-  function getTitle(): string {
-    if (isInstalled) return "Update installed";
-    if (isInstalling) return "Installing update";
-    if (isError) return "Update failed";
-    return "Update available";
-  }
-
-  function getSubtitle(): string {
-    if (isInstalled) return "Restart to use the new version.";
-    if (isInstalling) return "Downloading and installing...";
-    if (isError) return errorMessage ?? "Something went wrong.";
-    return `${availableUpdate?.latestVersion ? `v${availableUpdate.latestVersion.replace(/^v/i, "")} is ready` : "A new version is ready"} to install.`;
-  }
 
   return (
     <View style={styles.container} pointerEvents="box-none">
-      <Pressable onPress={() => setDismissed(true)} hitSlop={8} style={styles.closeButton}>
-        <X size={12} color={theme.colors.foregroundMuted} />
-      </Pressable>
-
       <View style={styles.banner}>
+        <Pressable onPress={() => setDismissed(true)} hitSlop={8} style={styles.closeButton}>
+          <X size={14} color={theme.colors.foregroundMuted} />
+        </Pressable>
+
         <View style={styles.textSection}>
-          <Text style={styles.title}>{getTitle()}</Text>
-          <Text style={styles.subtitle}>{getSubtitle()}</Text>
+          <Text style={styles.title}>{isInstalled ? "Update installed" : "Update available"}</Text>
+          <Text style={styles.subtitle}>
+            {isInstalled
+              ? "Restart to use the new version."
+              : `${availableUpdate?.latestVersion ? `v${availableUpdate.latestVersion.replace(/^v/i, "")} is ready` : "A new version is ready"} to install.`}
+          </Text>
         </View>
 
         <View style={styles.actions}>
@@ -80,7 +61,7 @@ export function UpdateBanner() {
             <Text style={styles.outlineButtonText}>What's new</Text>
           </Pressable>
 
-          {!isInstalled && !isError && (
+          {!isInstalled && (
             <Pressable
               onPress={() => void installUpdate()}
               disabled={isInstalling}
@@ -95,15 +76,6 @@ export function UpdateBanner() {
               </Text>
             </Pressable>
           )}
-
-          {isError && (
-            <Pressable
-              onPress={() => void checkForUpdates()}
-              style={({ pressed }) => [styles.primaryButton, pressed && styles.buttonPressed]}
-            >
-              <Text style={styles.primaryButtonText}>Retry</Text>
-            </Pressable>
-          )}
         </View>
       </View>
     </View>
@@ -137,21 +109,15 @@ const styles = StyleSheet.create((theme) => ({
   },
   closeButton: {
     position: "absolute",
-    top: -8,
-    left: -8,
-    width: 24,
-    height: 24,
-    borderRadius: 12,
-    backgroundColor: theme.colors.surface2,
-    borderWidth: theme.borderWidth[1],
-    borderColor: theme.colors.border,
-    alignItems: "center",
-    justifyContent: "center",
+    top: theme.spacing[2],
+    left: theme.spacing[2],
+    padding: theme.spacing[1],
     zIndex: 1,
   },
   textSection: {
     flex: 1,
     gap: 2,
+    paddingTop: theme.spacing[1],
   },
   title: {
     color: theme.colors.foreground,

packages/app/src/hooks/use-agent-form-state.ts

@@ -13,7 +13,6 @@ import { useHosts } from "@/runtime/host-runtime";
 import { useHostRuntimeClient, useHostRuntimeIsConnected } from "@/runtime/host-runtime";
 import {
   useFormPreferences,
-  mergeProviderPreferences,
   type FormPreferences,
   type ProviderPreferences,
 } from "./use-form-preferences";
@@ -694,23 +693,26 @@ export function useAgentFormState(options: UseAgentFormStateOptions = {}): UseAg
   const persistFormPreferences = useCallback(async () => {
     const resolvedModel = resolveEffectiveModel(availableModels, formState.model);
     const modelId = resolvedModel?.id ?? formState.model;
-    const nextPreferences = mergeProviderPreferences({
-      preferences: preferences ?? {},
-      provider: formState.provider,
-      updates: {
-        model: modelId || undefined,
-        mode: formState.modeId || undefined,
-        ...(modelId && formState.thinkingOptionId
-          ? {
-              thinkingByModel: {
-                [modelId]: formState.thinkingOptionId,
-              },
-            }
-          : {}),
-      } satisfies Partial<ProviderPreferences>,
-    });
+    const existingProviderPrefs = preferences?.providerPreferences?.[formState.provider];
 
-    await updatePreferences(nextPreferences);
+    const nextProviderPrefs: ProviderPreferences = {
+      model: modelId || undefined,
+      mode: formState.modeId || undefined,
+      thinkingByModel: {
+        ...existingProviderPrefs?.thinkingByModel,
+        ...(modelId && formState.thinkingOptionId
+          ? { [modelId]: formState.thinkingOptionId }
+          : {}),
+      },
+    };
+
+    await updatePreferences({
+      provider: formState.provider,
+      providerPreferences: {
+        ...preferences?.providerPreferences,
+        [formState.provider]: nextProviderPrefs,
+      },
+    });
   }, [
     availableModels,
     formState.model,

packages/app/src/hooks/use-form-preferences.test.ts

@@ -1,57 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import { mergeProviderPreferences } from "./use-form-preferences";
-
-describe("mergeProviderPreferences", () => {
-  it("stores the selected model for a provider", () => {
-    expect(
-      mergeProviderPreferences({
-        preferences: {},
-        provider: "claude",
-        updates: { model: "claude-opus-4-6" },
-      }),
-    ).toEqual({
-      provider: "claude",
-      providerPreferences: {
-        claude: {
-          model: "claude-opus-4-6",
-        },
-      },
-    });
-  });
-
-  it("merges thinking preferences by model without dropping existing entries", () => {
-    expect(
-      mergeProviderPreferences({
-        preferences: {
-          provider: "claude",
-          providerPreferences: {
-            claude: {
-              model: "claude-sonnet-4-6",
-              thinkingByModel: {
-                "claude-sonnet-4-6": "medium",
-              },
-            },
-          },
-        },
-        provider: "claude",
-        updates: {
-          thinkingByModel: {
-            "claude-opus-4-6": "high",
-          },
-        },
-      }),
-    ).toEqual({
-      provider: "claude",
-      providerPreferences: {
-        claude: {
-          model: "claude-sonnet-4-6",
-          thinkingByModel: {
-            "claude-sonnet-4-6": "medium",
-            "claude-opus-4-6": "high",
-          },
-        },
-      },
-    });
-  });
-});

packages/app/src/hooks/use-form-preferences.ts

@@ -2,7 +2,6 @@ import { useCallback } from "react";
 import AsyncStorage from "@react-native-async-storage/async-storage";
 import { useQuery, useQueryClient } from "@tanstack/react-query";
 import { z } from "zod";
-import type { AgentProvider } from "@server/server/agent/agent-sdk-types";
 
 const FORM_PREFERENCES_STORAGE_KEY = "@paseo:create-agent-preferences";
 const FORM_PREFERENCES_QUERY_KEY = ["form-preferences"];
@@ -36,36 +35,6 @@ export interface UseFormPreferencesReturn {
   updatePreferences: (updates: Partial<FormPreferences>) => Promise<void>;
 }
 
-export function mergeProviderPreferences(args: {
-  preferences: FormPreferences;
-  provider: AgentProvider;
-  updates: Partial<ProviderPreferences>;
-}): FormPreferences {
-  const { preferences, provider, updates } = args;
-  const existingProviderPreferences = preferences.providerPreferences ?? {};
-  const existing = existingProviderPreferences[provider] ?? {};
-  const nextThinkingByModel =
-    updates.thinkingByModel === undefined
-      ? existing.thinkingByModel
-      : {
-          ...existing.thinkingByModel,
-          ...updates.thinkingByModel,
-        };
-
-  return {
-    ...preferences,
-    provider,
-    providerPreferences: {
-      ...existingProviderPreferences,
-      [provider]: {
-        ...existing,
-        ...updates,
-        ...(nextThinkingByModel ? { thinkingByModel: nextThinkingByModel } : {}),
-      },
-    },
-  };
-}
-
 export function useFormPreferences(): UseFormPreferencesReturn {
   const queryClient = useQueryClient();
   const { data, isPending } = useQuery({

packages/app/src/hooks/use-settings.test.ts

@@ -30,16 +30,6 @@ describe("use-settings", () => {
     );
   });
 
-  it("defaults theme to auto when storage is empty", async () => {
-    asyncStorageMock.getItem.mockResolvedValue(null);
-    asyncStorageMock.setItem.mockResolvedValue();
-
-    const mod = await import("./use-settings");
-    const result = await mod.loadSettingsFromStorage();
-
-    expect(result.theme).toBe("auto");
-  });
-
   it("loads persisted built-in daemon management state", async () => {
     asyncStorageMock.getItem.mockImplementation(async (key: string) => {
       if (key === "@paseo:app-settings") {

packages/app/src/hooks/use-settings.ts

@@ -12,7 +12,7 @@ export interface AppSettings {
 }
 
 export const DEFAULT_APP_SETTINGS: AppSettings = {
-  theme: "auto",
+  theme: "dark",
   manageBuiltInDaemon: true,
 };
 

packages/app/src/runtime/host-runtime.ts

@@ -15,10 +15,7 @@ import {
 } from "@/types/host-connection";
 import { decodeOfferFragmentPayload, normalizeHostPort } from "@/utils/daemon-endpoints";
 import { ConnectionOfferSchema, type ConnectionOffer } from "@server/shared/connection-offer";
-import {
-  shouldUseDesktopDaemon,
-  startDesktopDaemon,
-} from "@/desktop/daemon/desktop-daemon";
+import { shouldUseDesktopDaemon, startDesktopDaemon } from "@/desktop/daemon/desktop-daemon";
 import { connectToDaemon } from "@/utils/test-daemon-connection";
 import { buildDaemonWebSocketUrl, buildRelayWebSocketUrl } from "@/utils/daemon-endpoints";
 import { getOrCreateClientId } from "@/utils/client-id";
@@ -36,10 +33,6 @@ import { useSessionStore, type Agent } from "@/stores/session-store";
 
 export type HostRuntimeConnectionStatus = "idle" | "connecting" | "online" | "offline" | "error";
 
-export type HostRuntimeBootstrapResult =
-  | { ok: true; listenAddress: string; serverId: string; hostname: string | null }
-  | { ok: false; error: string };
-
 export type ActiveConnection =
   | { type: "directTcp"; endpoint: string; display: string }
   | { type: "directSocket"; endpoint: string; display: "socket" }
@@ -1080,7 +1073,6 @@ const DEFAULT_LOCALHOST_ENDPOINT =
   process.env.EXPO_PUBLIC_LOCAL_DAEMON?.trim() || "localhost:6767";
 const DEFAULT_LOCALHOST_BOOTSTRAP_KEY = "@paseo:default-localhost-bootstrap-v1";
 const DEFAULT_LOCALHOST_BOOTSTRAP_TIMEOUT_MS = 2500;
-const CONNECTION_ONLINE_TIMEOUT_MS = 15_000;
 const E2E_STORAGE_KEY = "@paseo:e2e";
 
 export class HostRuntimeStore {
@@ -1169,40 +1161,35 @@ export class HostRuntimeStore {
     }
   }
 
-  async bootstrapDesktop(): Promise<HostRuntimeBootstrapResult> {
-    try {
-      const daemon = await startDesktopDaemon();
-      const listenAddress = daemon.listen.trim();
-      const serverId = daemon.serverId.trim();
-      if (!listenAddress) {
-        return {
-          ok: false,
-          error: "Desktop daemon did not return a listen address.",
-        };
+  private async bootstrapDesktop(): Promise<void> {
+    let lastError: unknown = null;
+
+    for (let attempt = 1; attempt <= 3; attempt += 1) {
+      try {
+        const daemon = await startDesktopDaemon();
+        const connection = connectionFromListen(daemon.listen);
+        if (!connection || !daemon.serverId) {
+          return;
+        }
+        await this.upsertHostConnection({
+          serverId: daemon.serverId,
+          label: daemon.hostname ?? undefined,
+          connection,
+        });
+        return;
+      } catch (error) {
+        lastError = error;
+        console.warn(`[HostRuntime] Failed to bootstrap desktop daemon (attempt ${attempt}/3)`, error);
+        if (attempt < 3) {
+          await new Promise((resolve) => {
+            setTimeout(resolve, attempt * 500);
+          });
+        }
       }
-      if (!serverId) {
-        return {
-          ok: false,
-          error: "Desktop daemon did not return a server id.",
-        };
-      }
-      if (!connectionFromListen(listenAddress)) {
-        return {
-          ok: false,
-          error: `Desktop daemon returned an unsupported listen address: ${listenAddress}`,
-        };
-      }
-      return {
-        ok: true,
-        listenAddress,
-        serverId,
-        hostname: daemon.hostname,
-      };
-    } catch (error) {
-      return {
-        ok: false,
-        error: toErrorMessage(error),
-      };
+    }
+
+    if (lastError) {
+      console.warn("[HostRuntime] Desktop daemon bootstrap exhausted retries", lastError);
     }
   }
 
@@ -1308,36 +1295,6 @@ export class HostRuntimeStore {
     return this.upsertConnectionFromOffer(offer);
   }
 
-  async addConnectionFromListenAndWaitForOnline(input: {
-    listenAddress: string;
-    serverId: string;
-    hostname: string | null;
-    timeoutMs?: number;
-  }): Promise<HostProfile> {
-    const normalizedListenAddress = input.listenAddress.trim();
-    const serverId = input.serverId.trim();
-    const connection = connectionFromListen(normalizedListenAddress);
-    if (!connection) {
-      throw new Error(`Unsupported listen address: ${input.listenAddress}`);
-    }
-    if (!serverId) {
-      throw new Error("Desktop daemon did not return a server id.");
-    }
-    const profile = await this.upsertHostConnection({
-      serverId,
-      label: input.hostname ?? undefined,
-      connection,
-    });
-
-    await this.waitForConnectionOnline({
-      serverId,
-      connectionId: connection.id,
-      timeoutMs: input.timeoutMs,
-    });
-
-    return profile;
-  }
-
   async renameHost(serverId: string, label: string): Promise<void> {
     const next = this.hosts.map((h) =>
       h.serverId === serverId ? { ...h, label, updatedAt: new Date().toISOString() } : h,
@@ -1499,100 +1456,6 @@ export class HostRuntimeStore {
     }
   }
 
-  private waitForConnectionOnline(input: {
-    serverId: string;
-    connectionId: string;
-    timeoutMs?: number;
-  }): Promise<void> {
-    const { serverId, connectionId } = input;
-    const timeoutMs = input.timeoutMs ?? CONNECTION_ONLINE_TIMEOUT_MS;
-
-    return new Promise((resolve, reject) => {
-      let settled = false;
-      let timeoutHandle: ReturnType<typeof setTimeout> | null = null;
-
-      const cleanup = (unsubscribe: (() => void) | null): void => {
-        if (timeoutHandle) {
-          clearTimeout(timeoutHandle);
-          timeoutHandle = null;
-        }
-        unsubscribe?.();
-      };
-
-      const settle = (
-        unsubscribe: (() => void) | null,
-        outcome: { ok: true } | { ok: false; error: Error },
-      ): void => {
-        if (settled) {
-          return;
-        }
-        settled = true;
-        cleanup(unsubscribe);
-        if (outcome.ok) {
-          resolve();
-        } else {
-          reject(outcome.error);
-        }
-      };
-
-      const readSnapshot = (): { ok: true } | { ok: false; error: Error } | null => {
-        const snapshot = this.getSnapshot(serverId);
-        if (!snapshot) {
-          return {
-            ok: false,
-            error: new Error(`Unknown host runtime for serverId ${serverId}`),
-          };
-        }
-
-        if (
-          snapshot.activeConnectionId === connectionId &&
-          snapshot.connectionStatus === "online"
-        ) {
-          return { ok: true };
-        }
-
-        if (
-          snapshot.activeConnectionId === connectionId &&
-          snapshot.connectionStatus === "error"
-        ) {
-          return {
-            ok: false,
-            error: new Error(snapshot.lastError ?? "Connection failed before coming online."),
-          };
-        }
-
-        return null;
-      };
-
-      const unsubscribe = this.subscribe(serverId, () => {
-        const outcome = readSnapshot();
-        if (outcome) {
-          settle(unsubscribe, outcome);
-        }
-      });
-
-      timeoutHandle = setTimeout(() => {
-        settle(unsubscribe, {
-          ok: false,
-          error: new Error(`Timed out waiting for connection ${connectionId} to come online.`),
-        });
-      }, timeoutMs);
-
-      const initialOutcome = readSnapshot();
-      if (initialOutcome) {
-        settle(unsubscribe, initialOutcome);
-        return;
-      }
-
-      void this.runProbeCycleNow(serverId).catch((error) => {
-        settle(unsubscribe, {
-          ok: false,
-          error: error instanceof Error ? error : new Error(String(error)),
-        });
-      });
-    });
-  }
-
   private maybeAutoBootstrapAgentDirectory(serverId: string): void {
     const controller = this.controllers.get(serverId);
     if (!controller) {

packages/app/src/screens/open-project-screen.tsx

@@ -1,22 +1,27 @@
 import { useEffect } from "react";
-import { View, Text } from "react-native";
-import { StyleSheet, UnistylesRuntime } from "react-native-unistyles";
+import { View, Text, Pressable } from "react-native";
+import { StyleSheet, UnistylesRuntime, useUnistyles } from "react-native-unistyles";
+import { useSafeAreaInsets } from "react-native-safe-area-context";
 import { FolderOpen } from "lucide-react-native";
 import { PaseoLogo } from "@/components/icons/paseo-logo";
-import { Button } from "@/components/ui/button";
-import { MenuHeader } from "@/components/headers/menu-header";
+import { SidebarMenuToggle } from "@/components/headers/menu-header";
 import { useOpenProjectPicker } from "@/hooks/use-open-project-picker";
 import { usePanelStore } from "@/stores/panel-store";
-import { useSessionStore } from "@/stores/session-store";
-import { useDesktopDragHandlers } from "@/utils/desktop-window";
+import { useDesktopDragHandlers, useTrafficLightPadding } from "@/utils/desktop-window";
 
 export function OpenProjectScreen({ serverId }: { serverId: string }) {
+  const { theme } = useUnistyles();
+  const insets = useSafeAreaInsets();
+  const trafficLightPadding = useTrafficLightPadding();
+  const desktopAgentListOpen = usePanelStore((s) => s.desktop.agentListOpen);
   const openAgentList = usePanelStore((s) => s.openAgentList);
   const openProjectPicker = useOpenProjectPicker(serverId);
-  const hasHydrated = useSessionStore((s) => s.sessions[serverId]?.hasHydratedWorkspaces ?? false);
-  const hasProjects = useSessionStore((s) => (s.sessions[serverId]?.workspaces?.size ?? 0) > 0);
 
   const isMobile = UnistylesRuntime.breakpoint === "xs" || UnistylesRuntime.breakpoint === "sm";
+  const collapsedSidebarInset =
+    !isMobile && !desktopAgentListOpen && trafficLightPadding.side
+      ? trafficLightPadding
+      : { left: 0, right: 0 };
   const dragHandlers = useDesktopDragHandlers();
 
   useEffect(() => {
@@ -27,24 +32,22 @@ export function OpenProjectScreen({ serverId }: { serverId: string }) {
 
   return (
     <View style={styles.container} {...dragHandlers}>
-      <MenuHeader borderless />
+      <View style={[styles.menuToggle, { paddingTop: insets.top, paddingLeft: collapsedSidebarInset.left, paddingRight: collapsedSidebarInset.right }]}>
+        <SidebarMenuToggle />
+      </View>
       <View style={styles.content}>
-        <View style={styles.logo}>
-          <PaseoLogo size={56} />
-        </View>
-        <View style={styles.headingGroup}>
-          <Text style={styles.heading}>What shall we build today?</Text>
-          {hasHydrated && !hasProjects ? (
-            <Text style={styles.subtitle}>
-              Add a project folder to start running agents on your codebase
-            </Text>
-          ) : null}
-        </View>
-        <View style={styles.cta}>
-          <Button variant="default" leftIcon={FolderOpen} onPress={() => void openProjectPicker()} testID="open-project-submit">
-            Add a project
-          </Button>
-        </View>
+        <PaseoLogo size={56} />
+        <Text style={styles.heading}>What shall we build today?</Text>
+        <Pressable
+          style={({ hovered }) => [styles.openButton, hovered && styles.openButtonHovered]}
+          onPress={() => {
+            void openProjectPicker();
+          }}
+          testID="open-project-submit"
+        >
+          <FolderOpen size={16} color={theme.colors.foregroundMuted} />
+          <Text style={styles.openButtonText}>Add a project</Text>
+        </Pressable>
       </View>
     </View>
   );
@@ -56,32 +59,43 @@ const styles = StyleSheet.create((theme) => ({
     backgroundColor: theme.colors.surface0,
     userSelect: "none",
   },
+  menuToggle: {
+    position: "absolute",
+    top: theme.spacing[3],
+    left: theme.spacing[3],
+    zIndex: 1,
+  },
   content: {
     flexGrow: 1,
     justifyContent: "center",
     alignItems: "center",
-    gap: 0,
+    gap: theme.spacing[6],
     padding: theme.spacing[6],
   },
-  logo: {
-    marginBottom: theme.spacing[8],
-  },
-  headingGroup: {
-    alignItems: "center",
-    gap: theme.spacing[3],
-  },
-  cta: {
-    marginTop: theme.spacing[12],
-  },
   heading: {
     color: theme.colors.foreground,
     fontSize: theme.fontSize["2xl"],
     fontWeight: theme.fontWeight.normal,
     textAlign: "center",
   },
-  subtitle: {
+  openButton: {
+    flexDirection: "row",
+    alignItems: "center",
+    gap: theme.spacing[2],
+    paddingVertical: theme.spacing[3],
+    paddingHorizontal: theme.spacing[4],
+    borderRadius: theme.borderRadius.lg,
+    borderWidth: 1,
+    borderColor: theme.colors.border,
+    backgroundColor: "transparent",
+  },
+  openButtonHovered: {
+    borderColor: theme.colors.borderAccent,
+    backgroundColor: theme.colors.surface1,
+  },
+  openButtonText: {
     color: theme.colors.foregroundMuted,
-    fontSize: theme.fontSize.base,
-    textAlign: "center",
+    fontSize: theme.fontSize.sm,
+    fontWeight: theme.fontWeight.normal,
   },
 }));

packages/app/src/screens/sessions-screen.tsx

@@ -1,14 +1,10 @@
 import { useMemo, useState, useCallback, useEffect } from "react";
-import { View, Text } from "react-native";
+import { View } from "react-native";
 import { useIsFocused } from "@react-navigation/native";
-import { router } from "expo-router";
 import { StyleSheet } from "react-native-unistyles";
-import { ChevronLeft } from "lucide-react-native";
 import { MenuHeader } from "@/components/headers/menu-header";
-import { Button } from "@/components/ui/button";
 import { AgentList } from "@/components/agent-list";
 import { useAllAgentsList } from "@/hooks/use-all-agents-list";
-import { buildHostOpenProjectRoute } from "@/utils/host-routes";
 
 export function SessionsScreen({ serverId }: { serverId: string }) {
   const isFocused = useIsFocused();
@@ -48,26 +44,13 @@ function SessionsScreenContent({ serverId }: { serverId: string }) {
   return (
     <View style={styles.container}>
       <MenuHeader title="Sessions" />
-      {sortedAgents.length === 0 ? (
-        <View style={styles.emptyContainer}>
-          <Text style={styles.emptyText}>No sessions yet</Text>
-          <Button
-            variant="ghost"
-            leftIcon={ChevronLeft}
-            onPress={() => router.navigate(buildHostOpenProjectRoute(serverId) as any)}
-          >
-            Back
-          </Button>
-        </View>
-      ) : (
-        <AgentList
-          agents={sortedAgents}
-          showCheckoutInfo={false}
-          isRefreshing={isManualRefresh && isRevalidating}
-          onRefresh={handleRefresh}
-          showAttentionIndicator={false}
-        />
-      )}
+      <AgentList
+        agents={sortedAgents}
+        showCheckoutInfo={false}
+        isRefreshing={isManualRefresh && isRevalidating}
+        onRefresh={handleRefresh}
+        showAttentionIndicator={false}
+      />
     </View>
   );
 }
@@ -77,15 +60,4 @@ const styles = StyleSheet.create((theme) => ({
     flex: 1,
     backgroundColor: theme.colors.surface0,
   },
-  emptyContainer: {
-    flex: 1,
-    justifyContent: "center",
-    alignItems: "center",
-    gap: theme.spacing[6],
-    padding: theme.spacing[6],
-  },
-  emptyText: {
-    color: theme.colors.foregroundMuted,
-    fontSize: theme.fontSize.lg,
-  },
 }));

packages/app/src/screens/startup-splash-screen.tsx

@@ -1,318 +1,29 @@
-import { useEffect, useMemo, useState } from "react";
-import { ActivityIndicator, Platform, ScrollView, Text, View } from "react-native";
-import * as Clipboard from "expo-clipboard";
-import { openExternalUrl } from "@/utils/open-external-url";
-import { BookOpen, Check, Copy, RotateCw, TriangleAlert } from "lucide-react-native";
-import { StyleSheet, useUnistyles } from "react-native-unistyles";
+import { Text, View } from "react-native";
+import { StyleSheet } from "react-native-unistyles";
 import { PaseoLogo } from "@/components/icons/paseo-logo";
-import { Button } from "@/components/ui/button";
-import { Fonts } from "@/constants/theme";
-import {
-  getDesktopDaemonLogs,
-  type DesktopDaemonLogs,
-} from "@/desktop/daemon/desktop-daemon";
 import { useDesktopDragHandlers } from "@/utils/desktop-window";
 
-type StartupSplashScreenProps = {
-  bootstrapState?: {
-    phase: "starting-daemon" | "connecting" | "online" | "error";
-    error: string | null;
-    retry: () => void;
-  };
-};
-
-const GITHUB_ISSUE_URL = "https://github.com/getpaseo/paseo/issues/new";
-const DOCS_URL = "https://paseo.sh/docs";
-
 const styles = StyleSheet.create((theme) => ({
   container: {
     flex: 1,
-    alignItems: "center",
     justifyContent: "center",
+    alignItems: "center",
     backgroundColor: theme.colors.surface0,
-    paddingHorizontal: theme.spacing[8],
-    paddingVertical: theme.spacing[8],
   },
-  containerError: {
-    justifyContent: "flex-start",
-    paddingTop: theme.spacing[16],
-  },
-  centeredContent: {
-    alignItems: "center",
-    justifyContent: "center",
-    maxWidth: 520,
-    width: "100%",
-  },
-  errorContent: {
-    alignItems: "stretch",
-    maxWidth: 720,
-    width: "100%",
-    gap: theme.spacing[6],
-  },
-  errorHeader: {
-    alignItems: "flex-start",
-  },
-  title: {
-    marginTop: theme.spacing[8],
-    color: theme.colors.foreground,
-    fontSize: theme.fontSize["3xl"],
-    fontWeight: theme.fontWeight.semibold,
-    textAlign: "center",
-  },
-  titleError: {
-    textAlign: "left",
-  },
-  subtitleRow: {
-    marginTop: theme.spacing[4],
-    flexDirection: "row",
-    alignItems: "center",
-    gap: theme.spacing[3],
-  },
-  progressSteps: {
-    marginTop: theme.spacing[4],
-    gap: theme.spacing[3],
-    width: "100%",
-  },
-  progressStepRow: {
-    flexDirection: "row",
-    alignItems: "center",
-    justifyContent: "center",
-    gap: theme.spacing[3],
-  },
-  subtitle: {
+  status: {
     marginTop: theme.spacing[8],
     color: theme.colors.foregroundMuted,
     fontSize: theme.fontSize.lg,
-    textAlign: "center",
-  },
-  subtitleInline: {
-    color: theme.colors.foregroundMuted,
-    fontSize: theme.fontSize.lg,
-    textAlign: "center",
-  },
-  errorDescription: {
-    color: theme.colors.foregroundMuted,
-    fontSize: theme.fontSize.base,
-    lineHeight: 22,
-  },
-  errorMessage: {
-    color: theme.colors.destructive,
-    fontSize: theme.fontSize.sm,
-    lineHeight: 20,
-    fontFamily: Fonts.mono,
-  },
-  logsMeta: {
-    color: theme.colors.foregroundMuted,
-    fontSize: theme.fontSize.sm,
-  },
-  logsContainer: {
-    height: 200,
-    borderRadius: theme.borderRadius.xl,
-    backgroundColor: theme.colors.surface1,
-    borderWidth: theme.borderWidth[1],
-    borderColor: theme.colors.border,
-    overflow: "hidden",
-  },
-  logsScroll: {
-    flexGrow: 0,
-  },
-  logsContent: {
-    padding: theme.spacing[4],
-  },
-  logsText: {
-    fontFamily: Fonts.mono,
-    fontSize: theme.fontSize.xs,
-    color: theme.colors.foreground,
-    lineHeight: 18,
-    ...(Platform.OS === "web"
-      ? {
-          whiteSpace: "pre",
-          overflowWrap: "normal",
-        }
-      : null),
-  },
-  actionRow: {
-    flexDirection: "row",
-    gap: theme.spacing[3],
-    flexWrap: "wrap",
   },
 }));
 
-export function StartupSplashScreen({ bootstrapState }: StartupSplashScreenProps) {
-  const { theme } = useUnistyles();
+export function StartupSplashScreen() {
   const dragHandlers = useDesktopDragHandlers();
-  const [daemonLogs, setDaemonLogs] = useState<DesktopDaemonLogs | null>(null);
-  const [logsError, setLogsError] = useState<string | null>(null);
-  const [isLoadingLogs, setIsLoadingLogs] = useState(false);
-
-  const phase = bootstrapState?.phase;
-  const isError = phase === "error";
-  const isSimpleSplash = bootstrapState === undefined;
-
-  useEffect(() => {
-    if (!isError) {
-      setDaemonLogs(null);
-      setLogsError(null);
-      setIsLoadingLogs(false);
-      return;
-    }
-
-    let isCancelled = false;
-    setIsLoadingLogs(true);
-    setLogsError(null);
-
-    void getDesktopDaemonLogs()
-      .then((logs) => {
-        if (isCancelled) {
-          return;
-        }
-        setDaemonLogs(logs);
-      })
-      .catch((error) => {
-        if (isCancelled) {
-          return;
-        }
-        const message = error instanceof Error ? error.message : String(error);
-        setDaemonLogs(null);
-        setLogsError(`Unable to load daemon logs: ${message}`);
-      })
-      .finally(() => {
-        if (!isCancelled) {
-          setIsLoadingLogs(false);
-        }
-      });
-
-    return () => {
-      isCancelled = true;
-    };
-  }, [isError]);
-
-  const progressSteps =
-    phase === "starting-daemon"
-      ? [{ key: "starting-daemon", label: "Starting local server...", status: "active" as const }]
-      : phase === "connecting"
-        ? [
-            { key: "starting-daemon", label: "Started local server", status: "complete" as const },
-            { key: "connecting", label: "Connecting to local server...", status: "active" as const },
-          ]
-        : [
-            { key: "starting-daemon", label: "Started local server", status: "complete" as const },
-            { key: "connecting", label: "Connected to local server", status: "complete" as const },
-          ];
-
-  const logsText = useMemo(() => {
-    if (isLoadingLogs) {
-      return "Loading daemon logs...";
-    }
-    if (daemonLogs?.contents) {
-      return daemonLogs.contents;
-    }
-    if (logsError) {
-      return logsError;
-    }
-    return "No daemon logs available.";
-  }, [daemonLogs?.contents, isLoadingLogs, logsError]);
-
-  const handleCopyLogs = () => {
-    const payload = daemonLogs?.logPath
-      ? `${daemonLogs.logPath}\n\n${daemonLogs.contents}`
-      : logsText;
-    void Clipboard.setStringAsync(payload);
-  };
-
-  if (isSimpleSplash) {
-    return (
-      <View style={styles.container} {...dragHandlers}>
-        <PaseoLogo size={96} />
-        <Text style={styles.subtitle}>Starting up…</Text>
-      </View>
-    );
-  }
-
-  if (!isError) {
-    return (
-      <View style={styles.container} {...dragHandlers}>
-        <View style={styles.centeredContent}>
-          <PaseoLogo size={96} />
-          <Text style={styles.title}>Welcome to Paseo</Text>
-          <View style={styles.progressSteps}>
-            {progressSteps.map((step) => (
-              <View key={step.key} style={styles.progressStepRow}>
-                {step.status === "complete" ? (
-                  <Check size={18} color={theme.colors.success} />
-                ) : (
-                  <ActivityIndicator color={theme.colors.accent} />
-                )}
-                <Text style={styles.subtitleInline}>{step.label}</Text>
-              </View>
-            ))}
-          </View>
-        </View>
-      </View>
-    );
-  }
 
   return (
-    <View style={[styles.container, styles.containerError]} {...dragHandlers}>
-      <View style={styles.errorContent}>
-        <View style={styles.errorHeader}>
-          <PaseoLogo size={64} />
-          <Text style={[styles.title, styles.titleError]}>Something went wrong</Text>
-        </View>
-
-        <Text style={styles.errorDescription}>
-          The local server failed to start. If this keeps happening, please report the issue on GitHub and include the logs below.
-        </Text>
-
-        <Text style={styles.errorMessage}>
-          {bootstrapState.error}
-        </Text>
-
-        {daemonLogs?.logPath ? <Text style={styles.logsMeta}>{daemonLogs.logPath}</Text> : null}
-
-        <View style={styles.logsContainer}>
-          <ScrollView
-            style={styles.logsScroll}
-            contentContainerStyle={styles.logsContent}
-            showsVerticalScrollIndicator
-          >
-            <Text selectable style={styles.logsText}>
-              {logsText}
-            </Text>
-          </ScrollView>
-        </View>
-
-        <View style={styles.actionRow}>
-          <Button
-            variant="secondary"
-            leftIcon={<Copy size={16} color={theme.colors.foreground} />}
-            onPress={handleCopyLogs}
-          >
-            Copy logs
-          </Button>
-          <Button
-            variant="outline"
-            leftIcon={<TriangleAlert size={16} color={theme.colors.foreground} />}
-            onPress={() => void openExternalUrl(GITHUB_ISSUE_URL)}
-          >
-            Open GitHub issue
-          </Button>
-          <Button
-            variant="outline"
-            leftIcon={<BookOpen size={16} color={theme.colors.foreground} />}
-            onPress={() => void openExternalUrl(DOCS_URL)}
-          >
-            Docs
-          </Button>
-          <Button
-            variant="default"
-            leftIcon={<RotateCw size={16} color={theme.colors.palette.white} />}
-            onPress={bootstrapState.retry}
-          >
-            Retry
-          </Button>
-        </View>
-      </View>
+    <View style={styles.container} {...dragHandlers}>
+      <PaseoLogo size={96} />
+      <Text style={styles.status}>Starting up…</Text>
     </View>
   );
 }

packages/app/src/terminal/runtime/terminal-emulator-runtime.ts

@@ -8,7 +8,6 @@ import { WebLinksAddon } from "@xterm/addon-web-links";
 import { WebglAddon } from "@xterm/addon-webgl";
 import { Terminal, type ITheme } from "@xterm/xterm";
 import type { TerminalState } from "@server/shared/messages";
-import { openExternalUrl } from "@/utils/open-external-url";
 import {
   type PendingTerminalModifiers,
   isTerminalModifierDomKey,
@@ -169,12 +168,7 @@ export class TerminalEmulatorRuntime {
     let webglAddon: WebglAddon | null = null;
     terminal.loadAddon(fitAddon);
     terminal.loadAddon(unicode11Addon);
-    terminal.loadAddon(
-      new WebLinksAddon((event, uri) => {
-        event.preventDefault();
-        void openExternalUrl(uri);
-      }),
-    );
+    terminal.loadAddon(new WebLinksAddon());
     terminal.loadAddon(new SearchAddon({ highlightLimit: 20_000 }));
     terminal.loadAddon(new ClipboardAddon());
     try {

packages/cli/src/cli.ts

@@ -2,11 +2,8 @@ import { Command } from "commander";
 import { createRequire } from "node:module";
 import { createAgentCommand } from "./commands/agent/index.js";
 import { createDaemonCommand } from "./commands/daemon/index.js";
-import { createChatCommand } from "./commands/chat/index.js";
-import { createLoopCommand } from "./commands/loop/index.js";
 import { createPermitCommand } from "./commands/permit/index.js";
 import { createProviderCommand } from "./commands/provider/index.js";
-import { createScheduleCommand } from "./commands/schedule/index.js";
 import { createSpeechCommand } from "./commands/speech/index.js";
 import { createWorktreeCommand } from "./commands/worktree/index.js";
 import { startCommand as daemonStartCommand } from "./commands/daemon/start.js";
@@ -140,15 +137,6 @@ export function createCli(): Command {
   // Daemon commands
   program.addCommand(createDaemonCommand());
 
-  // Chat commands
-  program.addCommand(createChatCommand());
-
-  // Loop commands
-  program.addCommand(createLoopCommand());
-
-  // Schedule commands
-  program.addCommand(createScheduleCommand());
-
   // Permission commands
   program.addCommand(createPermitCommand());
 

packages/cli/src/commands/chat/create.ts

@@ -1,31 +0,0 @@
-import type { Command } from "commander";
-import type { SingleResult } from "../../output/index.js";
-import { connectChatClient, toChatCommandError, type ChatCommandOptions } from "./shared.js";
-import { chatRoomSchema, type ChatRoomRow, toChatRoomRow } from "./schema.js";
-
-export interface ChatCreateOptions extends ChatCommandOptions {
-  purpose?: string;
-}
-
-export async function runCreateCommand(
-  name: string,
-  options: ChatCreateOptions,
-  _command: Command,
-): Promise<SingleResult<ChatRoomRow>> {
-  const { client } = await connectChatClient(options.host);
-  try {
-    const payload = await client.createChatRoom({
-      name,
-      purpose: options.purpose,
-    });
-    return {
-      type: "single",
-      data: toChatRoomRow(payload.room!),
-      schema: chatRoomSchema,
-    };
-  } catch (err) {
-    throw toChatCommandError("CHAT_CREATE_FAILED", "create chat room", err);
-  } finally {
-    await client.close().catch(() => {});
-  }
-}

packages/cli/src/commands/chat/delete.ts

@@ -1,24 +0,0 @@
-import type { Command } from "commander";
-import type { SingleResult } from "../../output/index.js";
-import { connectChatClient, toChatCommandError, type ChatCommandOptions } from "./shared.js";
-import { chatRoomSchema, type ChatRoomRow, toChatRoomRow } from "./schema.js";
-
-export async function runDeleteCommand(
-  room: string,
-  options: ChatCommandOptions,
-  _command: Command,
-): Promise<SingleResult<ChatRoomRow>> {
-  const { client } = await connectChatClient(options.host);
-  try {
-    const payload = await client.deleteChatRoom({ room });
-    return {
-      type: "single",
-      data: toChatRoomRow(payload.room!),
-      schema: chatRoomSchema,
-    };
-  } catch (err) {
-    throw toChatCommandError("CHAT_DELETE_FAILED", "delete chat room", err);
-  } finally {
-    await client.close().catch(() => {});
-  }
-}

packages/cli/src/commands/chat/index.ts

@@ -1,69 +0,0 @@
-import { Command } from "commander";
-import { withOutput } from "../../output/index.js";
-import { addJsonAndDaemonHostOptions } from "../../utils/command-options.js";
-import { runCreateCommand } from "./create.js";
-import { runLsCommand } from "./ls.js";
-import { runInspectCommand } from "./inspect.js";
-import { runDeleteCommand } from "./delete.js";
-import { runPostCommand } from "./post.js";
-import { runReadCommand } from "./read.js";
-import { runWaitCommand } from "./wait.js";
-
-export function createChatCommand(): Command {
-  const chat = new Command("chat").description("Manage chat rooms for agent coordination");
-
-  addJsonAndDaemonHostOptions(
-    chat
-      .command("create")
-      .description("Create a chat room")
-      .argument("<name>", "Room name (must be unique)")
-      .option("--purpose <text>", "Room purpose/description"),
-  ).action(withOutput(runCreateCommand));
-
-  addJsonAndDaemonHostOptions(
-    chat.command("ls").description("List chat rooms"),
-  ).action(withOutput(runLsCommand));
-
-  addJsonAndDaemonHostOptions(
-    chat
-      .command("inspect")
-      .description("Inspect a chat room")
-      .argument("<name-or-id>", "Room name or ID"),
-  ).action(withOutput(runInspectCommand));
-
-  addJsonAndDaemonHostOptions(
-    chat
-      .command("delete")
-      .description("Delete a chat room")
-      .argument("<name-or-id>", "Room name or ID"),
-  ).action(withOutput(runDeleteCommand));
-
-  addJsonAndDaemonHostOptions(
-    chat
-      .command("post")
-      .description("Post a chat message")
-      .argument("<name-or-id>", "Room name or ID")
-      .argument("<message>", "Message body")
-      .option("--reply-to <msg-id>", "Reply to a specific message ID"),
-  ).action(withOutput(runPostCommand));
-
-  addJsonAndDaemonHostOptions(
-    chat
-      .command("read")
-      .description("Read chat messages")
-      .argument("<name-or-id>", "Room name or ID")
-      .option("--limit <n>", "Maximum number of messages to return")
-      .option("--since <duration-or-timestamp>", "Filter by relative duration or ISO timestamp")
-      .option("--agent <agent-id>", "Filter by author agent ID"),
-  ).action(withOutput(runReadCommand));
-
-  addJsonAndDaemonHostOptions(
-    chat
-      .command("wait")
-      .description("Wait for new chat messages")
-      .argument("<name-or-id>", "Room name or ID")
-      .option("--timeout <duration>", "Maximum wait time"),
-  ).action(withOutput(runWaitCommand));
-
-  return chat;
-}

packages/cli/src/commands/chat/inspect.ts

@@ -1,24 +0,0 @@
-import type { Command } from "commander";
-import type { SingleResult } from "../../output/index.js";
-import { connectChatClient, toChatCommandError, type ChatCommandOptions } from "./shared.js";
-import { chatRoomSchema, type ChatRoomRow, toChatRoomRow } from "./schema.js";
-
-export async function runInspectCommand(
-  room: string,
-  options: ChatCommandOptions,
-  _command: Command,
-): Promise<SingleResult<ChatRoomRow>> {
-  const { client } = await connectChatClient(options.host);
-  try {
-    const payload = await client.inspectChatRoom({ room });
-    return {
-      type: "single",
-      data: toChatRoomRow(payload.room!),
-      schema: chatRoomSchema,
-    };
-  } catch (err) {
-    throw toChatCommandError("CHAT_INSPECT_FAILED", "inspect chat room", err);
-  } finally {
-    await client.close().catch(() => {});
-  }
-}

packages/cli/src/commands/chat/ls.ts

@@ -1,23 +0,0 @@
-import type { Command } from "commander";
-import type { ListResult } from "../../output/index.js";
-import { connectChatClient, toChatCommandError, type ChatCommandOptions } from "./shared.js";
-import { chatRoomSchema, type ChatRoomRow, toChatRoomRow } from "./schema.js";
-
-export async function runLsCommand(
-  options: ChatCommandOptions,
-  _command: Command,
-): Promise<ListResult<ChatRoomRow>> {
-  const { client } = await connectChatClient(options.host);
-  try {
-    const payload = await client.listChatRooms();
-    return {
-      type: "list",
-      data: payload.rooms.map(toChatRoomRow),
-      schema: chatRoomSchema,
-    };
-  } catch (err) {
-    throw toChatCommandError("CHAT_LIST_FAILED", "list chat rooms", err);
-  } finally {
-    await client.close().catch(() => {});
-  }
-}

packages/cli/src/commands/chat/post.ts

@@ -1,41 +0,0 @@
-import type { Command } from "commander";
-import type { SingleResult } from "../../output/index.js";
-import {
-  attachAgentNamesToMessages,
-  connectChatClient,
-  resolveChatAuthorAgentId,
-  toChatCommandError,
-  type ChatCommandOptions,
-} from "./shared.js";
-import { chatMessageSchema, type ChatMessageRow, toChatMessageRow } from "./schema.js";
-
-export interface ChatPostOptions extends ChatCommandOptions {
-  replyTo?: string;
-}
-
-export async function runPostCommand(
-  room: string,
-  body: string,
-  options: ChatPostOptions,
-  _command: Command,
-): Promise<SingleResult<ChatMessageRow>> {
-  const { client } = await connectChatClient(options.host);
-  try {
-    const payload = await client.postChatMessage({
-      room,
-      body,
-      authorAgentId: resolveChatAuthorAgentId(),
-      replyToMessageId: options.replyTo,
-    });
-    const [message] = await attachAgentNamesToMessages(client, [toChatMessageRow(payload.message!)]);
-    return {
-      type: "single",
-      data: message!,
-      schema: chatMessageSchema,
-    };
-  } catch (err) {
-    throw toChatCommandError("CHAT_POST_FAILED", "post chat message", err);
-  } finally {
-    await client.close().catch(() => {});
-  }
-}

packages/cli/src/commands/chat/read.ts

@@ -1,60 +0,0 @@
-import type { Command } from "commander";
-import type { ListResult } from "../../output/index.js";
-import {
-  attachAgentNamesToMessages,
-  connectChatClient,
-  parseSinceValue,
-  toChatCommandError,
-  type ChatCommandOptions,
-} from "./shared.js";
-import { chatMessageSchema, type ChatMessageRow, toChatMessageRow } from "./schema.js";
-
-export interface ChatReadOptions extends ChatCommandOptions {
-  limit?: string;
-  since?: string;
-  agent?: string;
-}
-
-function parseLimit(value?: string): number | undefined {
-  if (!value) {
-    return undefined;
-  }
-  const parsed = Number.parseInt(value, 10);
-  if (!Number.isInteger(parsed) || parsed < 0) {
-    throw {
-      code: "INVALID_LIMIT",
-      message: "Invalid --limit value",
-      details: "Use a non-negative integer.",
-    };
-  }
-  return parsed;
-}
-
-export async function runReadCommand(
-  room: string,
-  options: ChatReadOptions,
-  _command: Command,
-): Promise<ListResult<ChatMessageRow>> {
-  const { client } = await connectChatClient(options.host);
-  try {
-    const payload = await client.readChatMessages({
-      room,
-      limit: parseLimit(options.limit),
-      since: parseSinceValue(options.since),
-      authorAgentId: options.agent,
-    });
-    const messages = await attachAgentNamesToMessages(
-      client,
-      payload.messages.map(toChatMessageRow),
-    );
-    return {
-      type: "list",
-      data: messages,
-      schema: chatMessageSchema,
-    };
-  } catch (err) {
-    throw toChatCommandError("CHAT_READ_FAILED", "read chat messages", err);
-  } finally {
-    await client.close().catch(() => {});
-  }
-}

packages/cli/src/commands/chat/schema.ts

@@ -1,126 +0,0 @@
-import type { OutputSchema } from "../../output/index.js";
-import type { AnyCommandResult, OutputOptions } from "../../output/index.js";
-
-export interface ChatRoomRow {
-  name: string;
-  id: string;
-  purpose: string;
-  messages: number;
-  lastMessageAt: string;
-}
-
-export interface ChatMessageRow {
-  id: string;
-  author: string;
-  authorName: string | null;
-  createdAt: string;
-  replyTo: string;
-  mentionAgentIds: string[];
-  mentionLabels: string[];
-  body: string;
-}
-
-export const chatRoomSchema: OutputSchema<ChatRoomRow> = {
-  idField: "id",
-  columns: [
-    { header: "NAME", field: "name", width: 22 },
-    { header: "ID", field: "id", width: 36 },
-    { header: "PURPOSE", field: "purpose", width: 30 },
-    { header: "MESSAGES", field: "messages", width: 10, align: "right" },
-    { header: "LAST MESSAGE", field: "lastMessageAt", width: 24 },
-  ],
-};
-
-export const chatMessageSchema: OutputSchema<ChatMessageRow> = {
-  idField: "id",
-  columns: [
-    { header: "ID", field: "id", width: 36 },
-    { header: "AUTHOR", field: "author", width: 16 },
-    { header: "AUTHOR NAME", field: (row) => row.authorName ?? "-", width: 20 },
-    { header: "CREATED", field: "createdAt", width: 24 },
-    { header: "REPLY TO", field: "replyTo", width: 36 },
-    { header: "MENTIONS", field: (row) => row.mentionLabels.join(", ") || "-", width: 24 },
-    { header: "MESSAGE", field: "body", width: 60 },
-  ],
-  renderHuman: renderChatTranscript,
-};
-
-function renderChatTranscript(
-  result: AnyCommandResult<ChatMessageRow>,
-  _options: OutputOptions,
-): string {
-  const data = result.type === "list" ? result.data : [result.data];
-  if (data.length === 0) {
-    return "";
-  }
-  return data.map(renderChatMessageBlock).join("\n\n");
-}
-
-function renderChatMessageBlock(message: ChatMessageRow): string {
-  const authorLabel = message.authorName
-    ? `${message.authorName} (${message.author})`
-    : message.author;
-  const lines = [`┌─ ${authorLabel} ── ${formatTimestamp(message.createdAt)} ── [msg ${message.id}]`];
-
-  if (message.replyTo !== "-") {
-    lines.push(`│  reply-to: msg ${message.replyTo}`);
-  }
-  if (message.mentionLabels.length > 0) {
-    lines.push(`│  mentions: ${message.mentionLabels.join(", ")}`);
-  }
-
-  lines.push("│");
-
-  const bodyLines = message.body.split(/\r?\n/);
-  for (const line of bodyLines) {
-    lines.push(`│  ${line}`);
-  }
-
-  lines.push("│");
-  lines.push("└─");
-  return lines.join("\n");
-}
-
-function formatTimestamp(input: string): string {
-  const date = new Date(input);
-  if (Number.isNaN(date.getTime())) {
-    return input;
-  }
-  return date.toISOString().replace("T", " ").replace(".000Z", "Z");
-}
-
-export function toChatRoomRow(room: {
-  id: string;
-  name: string;
-  purpose: string | null;
-  messageCount: number;
-  lastMessageAt: string | null;
-}): ChatRoomRow {
-  return {
-    id: room.id,
-    name: room.name,
-    purpose: room.purpose ?? "-",
-    messages: room.messageCount,
-    lastMessageAt: room.lastMessageAt ?? "-",
-  };
-}
-
-export function toChatMessageRow(message: {
-  id: string;
-  authorAgentId: string;
-  createdAt: string;
-  replyToMessageId: string | null;
-  mentionAgentIds: string[];
-  body: string;
-}): ChatMessageRow {
-  return {
-    id: message.id,
-    author: message.authorAgentId,
-    authorName: null,
-    createdAt: message.createdAt,
-    replyTo: message.replyToMessageId ?? "-",
-    mentionAgentIds: message.mentionAgentIds,
-    mentionLabels: message.mentionAgentIds,
-    body: message.body,
-  };
-}

packages/cli/src/commands/chat/shared.ts

@@ -1,127 +0,0 @@
-import { connectToDaemon, getDaemonHost } from "../../utils/client.js";
-import { parseDuration } from "../../utils/duration.js";
-import type { CommandError, CommandOptions } from "../../output/index.js";
-import type { ChatMessageRow } from "./schema.js";
-
-export interface ChatCommandOptions extends CommandOptions {
-  host?: string;
-}
-
-export async function connectChatClient(host?: string) {
-  const daemonHost = getDaemonHost({ host });
-  try {
-    const client = await connectToDaemon({ host });
-    return { client, daemonHost };
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    const error: CommandError = {
-      code: "DAEMON_NOT_RUNNING",
-      message: `Cannot connect to daemon at ${daemonHost}: ${message}`,
-      details: "Start the daemon with: paseo daemon start",
-    };
-    throw error;
-  }
-}
-
-export async function attachAgentNamesToMessages(
-  client: Awaited<ReturnType<typeof connectToDaemon>>,
-  messages: ChatMessageRow[],
-): Promise<ChatMessageRow[]> {
-  const agentIds = new Set<string>();
-  for (const message of messages) {
-    agentIds.add(message.author);
-    for (const mentionId of message.mentionAgentIds) {
-      agentIds.add(mentionId);
-    }
-  }
-
-  if (agentIds.size === 0) {
-    return messages;
-  }
-
-  const payload = await client.fetchAgents({
-    filter: { includeArchived: true },
-  });
-  const agentNames = new Map<string, string>();
-  for (const entry of payload.entries) {
-    const title = entry.agent.title?.trim();
-    if (title) {
-      agentNames.set(entry.agent.id, title);
-    }
-  }
-
-  return messages.map((message) => ({
-    ...message,
-    authorName: agentNames.get(message.author) ?? null,
-    mentionLabels: message.mentionAgentIds.map((agentId) => {
-      const name = agentNames.get(agentId);
-      return name ? `${name} (${agentId})` : agentId;
-    }),
-  }));
-}
-
-export function toChatCommandError(code: string, action: string, err: unknown): CommandError {
-  if (err && typeof err === "object" && "code" in err && "message" in err) {
-    return err as CommandError;
-  }
-
-  const message = err instanceof Error ? err.message : String(err);
-  const rpcCode =
-    typeof err === "object" && err !== null && "code" in err && typeof err.code === "string"
-      ? err.code
-      : undefined;
-
-  return {
-    code: rpcCode ?? code,
-    message: `Failed to ${action}: ${message}`,
-  };
-}
-
-export function parseSinceValue(input?: string): string | undefined {
-  if (!input) {
-    return undefined;
-  }
-
-  try {
-    const durationMs = parseDuration(input);
-    return new Date(Date.now() - durationMs).toISOString();
-  } catch {
-    const timestamp = new Date(input);
-    if (Number.isNaN(timestamp.getTime())) {
-      const error: CommandError = {
-        code: "INVALID_SINCE",
-        message: "Invalid --since value",
-        details: "Use a duration like 10m or an ISO timestamp.",
-      };
-      throw error;
-    }
-    return timestamp.toISOString();
-  }
-}
-
-export function parseTimeoutMs(input?: string): number | undefined {
-  if (!input) {
-    return undefined;
-  }
-
-  try {
-    const timeoutMs = parseDuration(input);
-    if (timeoutMs <= 0) {
-      throw new Error("Timeout must be positive");
-    }
-    return timeoutMs;
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    const error: CommandError = {
-      code: "INVALID_TIMEOUT",
-      message: "Invalid timeout value",
-      details: message,
-    };
-    throw error;
-  }
-}
-
-export function resolveChatAuthorAgentId(): string {
-  const agentId = process.env.PASEO_AGENT_ID?.trim();
-  return agentId && agentId.length > 0 ? agentId : "manual";
-}

packages/cli/src/commands/chat/wait.ts

@@ -1,47 +0,0 @@
-import type { Command } from "commander";
-import type { ListResult } from "../../output/index.js";
-import {
-  attachAgentNamesToMessages,
-  connectChatClient,
-  parseTimeoutMs,
-  toChatCommandError,
-  type ChatCommandOptions,
-} from "./shared.js";
-import { chatMessageSchema, type ChatMessageRow, toChatMessageRow } from "./schema.js";
-
-export interface ChatWaitOptions extends ChatCommandOptions {
-  timeout?: string;
-}
-
-export async function runWaitCommand(
-  room: string,
-  options: ChatWaitOptions,
-  _command: Command,
-): Promise<ListResult<ChatMessageRow>> {
-  const { client } = await connectChatClient(options.host);
-  try {
-    const latest = await client.readChatMessages({
-      room,
-      limit: 1,
-    });
-    const afterMessageId = latest.messages[0]?.id;
-    const payload = await client.waitForChatMessages({
-      room,
-      afterMessageId,
-      timeoutMs: parseTimeoutMs(options.timeout),
-    });
-    const messages = await attachAgentNamesToMessages(
-      client,
-      payload.messages.map(toChatMessageRow),
-    );
-    return {
-      type: "list",
-      data: messages,
-      schema: chatMessageSchema,
-    };
-  } catch (err) {
-    throw toChatCommandError("CHAT_WAIT_FAILED", "wait for chat messages", err);
-  } finally {
-    await client.close().catch(() => {});
-  }
-}

packages/cli/src/commands/daemon/runtime-toolchain.ts

@@ -35,75 +35,29 @@ function resolveNodePathFromPidUnix(pid: number): NodePathFromPidResult {
   return resolved ? { nodePath: resolved } : { nodePath: null, error: "ps returned an empty command path" };
 }
 
-function runProcessProbe(command: string, args: string[]): {
-  resolved: string | null;
-  error?: string;
-} {
-  const result = spawnSync(command, args, {
-    encoding: "utf8",
-    stdio: ["ignore", "pipe", "pipe"],
-  });
+function resolveNodePathFromPidWindows(pid: number): NodePathFromPidResult {
+  const result = spawnSync(
+    "wmic",
+    ["process", "where", `ProcessId=${pid}`, "get", "ExecutablePath", "/VALUE"],
+    { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] },
+  );
 
   if (result.error) {
-    return { resolved: null, error: `${command} failed: ${normalizeError(result.error)}` };
+    return { nodePath: null, error: `wmic failed: ${normalizeError(result.error)}` };
   }
 
   if ((result.status ?? 1) !== 0) {
     const details = result.stderr?.trim();
     return {
-      resolved: null,
-      error: details ? `${command} failed: ${details}` : `${command} exited with code ${result.status ?? 1}`,
+      nodePath: null,
+      error: details ? `wmic failed: ${details}` : `wmic exited with code ${result.status ?? 1}`,
     };
   }
 
-  const resolved = result.stdout.trim();
-  return resolved ? { resolved } : { resolved: null, error: `${command} returned no executable path` };
-}
-
-function resolveNodePathFromPidWindows(pid: number): NodePathFromPidResult {
-  const probes: Array<{ label: string; command: string; args: string[]; parseValue?: (stdout: string) => string | null }> = [
-    {
-      label: "powershell-cim",
-      command: "powershell",
-      args: [
-        "-NoProfile",
-        "-Command",
-        `(Get-CimInstance Win32_Process -Filter "ProcessId = ${pid}").ExecutablePath`,
-      ],
-    },
-    {
-      label: "powershell-process",
-      command: "powershell",
-      args: ["-NoProfile", "-Command", `(Get-Process -Id ${pid}).Path`],
-    },
-    {
-      label: "wmic",
-      command: "wmic",
-      args: ["process", "where", `ProcessId=${pid}`, "get", "ExecutablePath", "/VALUE"],
-      parseValue: (stdout) => {
-        const match = stdout.match(/ExecutablePath=(.+)/);
-        return match?.[1]?.trim() ?? null;
-      },
-    },
-  ];
-
-  const errors: string[] = [];
-  for (const probe of probes) {
-    const result = runProcessProbe(probe.command, probe.args);
-    if (result.resolved) {
-      const resolved = probe.parseValue ? probe.parseValue(result.resolved) : result.resolved;
-      if (resolved) {
-        return { nodePath: resolved };
-      }
-      errors.push(`${probe.label} returned no executable path`);
-      continue;
-    }
-    if (result.error) {
-      errors.push(`${probe.label}: ${result.error}`);
-    }
-  }
-
-  return { nodePath: null, error: errors.join("; ") || "could not resolve executable path from PID" };
+  // wmic output format: "ExecutablePath=C:\path\to\node.exe\r\n"
+  const match = result.stdout.match(/ExecutablePath=(.+)/);
+  const resolved = match?.[1]?.trim();
+  return resolved ? { nodePath: resolved } : { nodePath: null, error: "wmic returned no executable path" };
 }
 
 export function resolveNodePathFromPid(pid: number): NodePathFromPidResult {

packages/cli/src/commands/daemon/status.ts

@@ -15,8 +15,7 @@ interface ProviderBinaryStatus {
 
 interface DaemonStatus {
   serverId: string | null;
-  localDaemon: "running" | "stopped" | "stale_pid" | "unresponsive";
-  connectedDaemon: "reachable" | "unreachable" | "not_probed";
+  status: "running" | "stopped" | "unresponsive";
   home: string;
   listen: string;
   hostname: string | null;
@@ -86,16 +85,11 @@ function createStatusSchema(status: DaemonStatus): OutputSchema<StatusRow> {
         header: "VALUE",
         field: "value",
         color: (_, item) => {
-          if (item.key === "Local Daemon") {
+          if (item.key === "Status") {
             if (item.value === "running") return "green";
             if (item.value === "unresponsive") return "yellow";
             return "red";
           }
-          if (item.key === "Connected Daemon") {
-            if (item.value === "reachable") return "green";
-            if (item.value === "not_probed") return "yellow";
-            return "red";
-          }
           if (item.key.startsWith("  ")) {
             if (item.value === "not found") return "red";
             if (item.value.endsWith("(--version failed)")) return "yellow";
@@ -112,8 +106,7 @@ function createStatusSchema(status: DaemonStatus): OutputSchema<StatusRow> {
 function toStatusRows(status: DaemonStatus): StatusRow[] {
   const rows: StatusRow[] = [
     { key: "Server ID", value: status.serverId ?? "-" },
-    { key: "Local Daemon", value: status.localDaemon },
-    { key: "Connected Daemon", value: status.connectedDaemon },
+    { key: "Status", value: status.status },
     { key: "Home", value: status.home },
     { key: "Listen", value: status.listen },
     { key: "Hostname", value: status.hostname ?? "-" },
@@ -206,7 +199,6 @@ export async function runStatusCommand(
 ): Promise<StatusResult> {
   const home = typeof options.home === "string" ? options.home : undefined;
   const state = resolveLocalDaemonState({ home });
-  const host = resolveTcpHostFromListen(state.listen);
 
   const owner = resolveOwnerLabel(state.pidInfo?.uid, state.pidInfo?.hostname);
   let daemonNode: string;
@@ -219,60 +211,38 @@ export async function runStatusCommand(
     daemonNode = "unknown (no PID available)";
   }
   const cliNode = process.execPath;
-  let localDaemon: DaemonStatus["localDaemon"] = state.running ? "running" : "stopped";
-  let connectedDaemon: DaemonStatus["connectedDaemon"] = "not_probed";
+  let status: DaemonStatus["status"] = state.running ? "running" : "stopped";
   let runningAgents: number | null = null;
   let idleAgents: number | null = null;
   let note: string | undefined;
 
   if (!state.running && state.stalePidFile && state.pidInfo) {
-    localDaemon = "stale_pid";
     note = `Stale PID file found for PID ${state.pidInfo.pid}`;
   }
 
-  if (host) {
-    const client = await tryConnectToDaemon({ host, timeout: 1500 });
-    if (client) {
-      connectedDaemon = "reachable";
-      try {
-        const agentsPayload = await client.fetchAgents({ filter: { includeArchived: true } });
-        const agents = agentsPayload.entries.map((entry) => entry.agent);
-        runningAgents = agents.filter((a) => a.status === "running").length;
-        idleAgents = agents.filter((a) => a.status === "idle").length;
-        if (!state.running) {
-          daemonNode = "unknown (API reachable, PID unresolved)";
-          note = appendNote(
-            note,
-            state.pidInfo
-              ? `Connected daemon is reachable at ${host} even though local daemon PID ${state.pidInfo.pid} is stale`
-              : `Connected daemon is reachable at ${host} but no local daemon PID file was found`,
-          );
+  if (state.running) {
+    const host = resolveTcpHostFromListen(state.listen);
+    if (host) {
+      const client = await tryConnectToDaemon({ host, timeout: 1500 });
+      if (client) {
+        try {
+          const agentsPayload = await client.fetchAgents({ filter: { includeArchived: true } });
+          const agents = agentsPayload.entries.map((entry) => entry.agent);
+          runningAgents = agents.filter((a) => a.status === "running").length;
+          idleAgents = agents.filter((a) => a.status === "idle").length;
+        } catch {
+          status = "unresponsive";
+          note = appendNote(note, `Daemon PID is running but API requests to ${host} failed`);
+        } finally {
+          await client.close().catch(() => {});
         }
-      } catch {
-        if (state.running) {
-          localDaemon = "unresponsive";
-        }
-        note = appendNote(
-          note,
-          state.running
-            ? `Local daemon PID is running but API requests to ${host} failed`
-            : `Connected daemon websocket is reachable at ${host} but fetch_agents failed`,
-        );
-      } finally {
-        await client.close().catch(() => {});
+      } else {
+        status = "unresponsive";
+        note = appendNote(note, `Daemon PID is running but websocket at ${host} is not reachable`);
       }
-    } else if (state.running) {
-      connectedDaemon = "unreachable";
-      localDaemon = "unresponsive";
-      note = appendNote(
-        note,
-        `Local daemon PID is running but websocket at ${host} is not reachable`,
-      );
     } else {
-      connectedDaemon = "unreachable";
+      note = appendNote(note, "Daemon is configured for unix socket listen; API probe skipped");
     }
-  } else {
-    note = appendNote(note, "Daemon is configured for unix socket listen; API probe skipped");
   }
 
   const cliVersion = resolveCliVersion();
@@ -288,8 +258,7 @@ export async function runStatusCommand(
 
   const daemonStatus: DaemonStatus = {
     serverId,
-    localDaemon,
-    connectedDaemon,
+    status,
     home: state.home,
     listen: state.listen,
     hostname: state.pidInfo?.hostname ?? null,

packages/cli/src/commands/loop/index.ts

@@ -1,34 +0,0 @@
-import { Command } from "commander";
-import { withOutput } from "../../output/index.js";
-import { addJsonAndDaemonHostOptions, addDaemonHostOption } from "../../utils/command-options.js";
-import { addLoopRunOptions, runLoopRunCommand } from "./run.js";
-import { addLoopLsOptions, runLoopLsCommand } from "./ls.js";
-import { addLoopInspectOptions, runLoopInspectCommand } from "./inspect.js";
-import { addLoopLogsOptions, runLoopLogsCommand } from "./logs.js";
-import { addLoopStopOptions, runLoopStopCommand } from "./stop.js";
-
-export function createLoopCommand(): Command {
-  const loop = new Command("loop").description("Run iterative worker loops");
-
-  addJsonAndDaemonHostOptions(
-    addLoopRunOptions(loop.command("run")),
-  ).action(withOutput(runLoopRunCommand));
-
-  addJsonAndDaemonHostOptions(
-    addLoopLsOptions(loop.command("ls")),
-  ).action(withOutput(runLoopLsCommand));
-
-  addJsonAndDaemonHostOptions(
-    addLoopInspectOptions(loop.command("inspect")),
-  ).action(withOutput(runLoopInspectCommand));
-
-  addDaemonHostOption(
-    addLoopLogsOptions(loop.command("logs")),
-  ).action(runLoopLogsCommand);
-
-  addJsonAndDaemonHostOptions(
-    addLoopStopOptions(loop.command("stop")),
-  ).action(withOutput(runLoopStopCommand));
-
-  return loop;
-}

packages/cli/src/commands/loop/inspect.ts

@@ -1,118 +0,0 @@
-import { Command } from "commander";
-import { connectToDaemon, getDaemonHost } from "../../utils/client.js";
-import type {
-  CommandOptions,
-  CommandError,
-  OutputSchema,
-  ListResult,
-} from "../../output/index.js";
-import type { LoopDaemonClient, LoopRecord } from "./types.js";
-
-interface InspectRow {
-  key: string;
-  value: string;
-}
-
-export interface LoopInspectOptions extends CommandOptions {}
-
-export function addLoopInspectOptions(command: Command): Command {
-  return command.description("Show loop details and iteration history").argument("<id>", "Loop ID");
-}
-
-function createInspectSchema(loop: LoopRecord): OutputSchema<InspectRow> {
-  return {
-    idField: "key",
-    columns: [
-      { header: "KEY", field: "key", width: 18 },
-      { header: "VALUE", field: "value", width: 80 },
-    ],
-    serialize: () => loop,
-  };
-}
-
-function toRows(loop: LoopRecord): InspectRow[] {
-  return [
-    { key: "Id", value: loop.id },
-    { key: "Name", value: loop.name ?? "null" },
-    { key: "Status", value: loop.status },
-    { key: "Cwd", value: loop.cwd },
-    { key: "Provider", value: loop.provider },
-    { key: "Model", value: loop.model ?? "null" },
-    { key: "WorkerProvider", value: loop.workerProvider ?? "null" },
-    { key: "WorkerModel", value: loop.workerModel ?? "null" },
-    { key: "VerifierProvider", value: loop.verifierProvider ?? "null" },
-    { key: "VerifierModel", value: loop.verifierModel ?? "null" },
-    { key: "Prompt", value: loop.prompt },
-    { key: "VerifyPrompt", value: loop.verifyPrompt ?? "null" },
-    { key: "VerifyChecks", value: loop.verifyChecks.length > 0 ? loop.verifyChecks.join(" | ") : "[]" },
-    { key: "Archive", value: String(loop.archive) },
-    { key: "SleepMs", value: String(loop.sleepMs) },
-    { key: "MaxIterations", value: loop.maxIterations === null ? "null" : String(loop.maxIterations) },
-    { key: "MaxTimeMs", value: loop.maxTimeMs === null ? "null" : String(loop.maxTimeMs) },
-    { key: "CreatedAt", value: loop.createdAt },
-    { key: "UpdatedAt", value: loop.updatedAt },
-    { key: "CompletedAt", value: loop.completedAt ?? "null" },
-    {
-      key: "Iterations",
-      value:
-        loop.iterations.length === 0
-          ? "[]"
-          : loop.iterations
-              .map((iteration) => {
-                const summary = [
-                  `#${iteration.index}`,
-                  iteration.status,
-                  iteration.workerAgentId ? `worker=${iteration.workerAgentId}` : null,
-                  iteration.verifierAgentId ? `verifier=${iteration.verifierAgentId}` : null,
-                  iteration.failureReason ? `reason=${iteration.failureReason}` : null,
-                ]
-                  .filter(Boolean)
-                  .join(" ");
-                return summary;
-              })
-              .join(" | "),
-    },
-  ];
-}
-
-export type LoopInspectResult = ListResult<InspectRow>;
-
-export async function runLoopInspectCommand(
-  id: string,
-  options: LoopInspectOptions,
-  _command: Command,
-): Promise<LoopInspectResult> {
-  const host = getDaemonHost({ host: options.host as string | undefined });
-  let client;
-  try {
-    client = (await connectToDaemon({
-      host: options.host as string | undefined,
-    })) as unknown as LoopDaemonClient;
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    throw {
-      code: "DAEMON_NOT_RUNNING",
-      message: `Cannot connect to daemon at ${host}: ${message}`,
-      details: "Start the daemon with: paseo daemon start",
-    } satisfies CommandError;
-  }
-
-  try {
-    const payload = await client.loopInspect(id);
-    await client.close();
-    if (payload.error || !payload.loop) {
-      throw new Error(payload.error ?? `Loop not found: ${id}`);
-    }
-    return {
-      type: "list",
-      data: toRows(payload.loop),
-      schema: createInspectSchema(payload.loop),
-    };
-  } catch (error) {
-    await client.close().catch(() => {});
-    throw {
-      code: "LOOP_INSPECT_FAILED",
-      message: error instanceof Error ? error.message : String(error),
-    } satisfies CommandError;
-  }
-}

packages/cli/src/commands/loop/logs.ts

@@ -1,82 +0,0 @@
-import { Command } from "commander";
-import { connectToDaemon, getDaemonHost } from "../../utils/client.js";
-import type { CommandError, CommandOptions } from "../../output/index.js";
-import type { LoopDaemonClient, LoopLogEntry } from "./types.js";
-
-export interface LoopLogsOptions extends CommandOptions {
-  pollInterval?: string;
-}
-
-export function addLoopLogsOptions(command: Command): Command {
-  return command
-    .description("Stream loop logs")
-    .argument("<id>", "Loop ID")
-    .option("--poll-interval <ms>", "Polling interval in milliseconds", "1000");
-}
-
-function parsePollInterval(value: string): number {
-  const parsed = Number.parseInt(value, 10);
-  if (!Number.isInteger(parsed) || parsed <= 0) {
-    throw {
-      code: "INVALID_POLL_INTERVAL",
-      message: "--poll-interval must be a positive integer",
-    } satisfies CommandError;
-  }
-  return parsed;
-}
-
-function renderLogEntry(entry: LoopLogEntry): string {
-  const prefix = [
-    entry.timestamp,
-    entry.source,
-    entry.iteration === null ? null : `iteration=${entry.iteration}`,
-    entry.level === "error" ? "ERROR" : null,
-  ]
-    .filter(Boolean)
-    .join(" ");
-  return `${prefix}\n${entry.text}`;
-}
-
-export async function runLoopLogsCommand(
-  id: string,
-  options: LoopLogsOptions,
-  _command: Command,
-): Promise<void> {
-  const host = getDaemonHost({ host: options.host as string | undefined });
-  const pollInterval = parsePollInterval(options.pollInterval ?? "1000");
-  let client;
-  try {
-    client = (await connectToDaemon({
-      host: options.host as string | undefined,
-    })) as unknown as LoopDaemonClient;
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    console.error(`Error: Cannot connect to daemon at ${host}: ${message}`);
-    console.error("Start the daemon with: paseo daemon start");
-    process.exit(1);
-  }
-
-  let cursor = 0;
-  try {
-    for (;;) {
-      const payload = await client.loopLogs(id, cursor);
-      if (payload.error || !payload.loop) {
-        throw new Error(payload.error ?? `Loop not found: ${id}`);
-      }
-      cursor = payload.nextCursor;
-      for (const entry of payload.entries) {
-        console.log(renderLogEntry(entry));
-      }
-      if (payload.loop.status !== "running") {
-        await client.close();
-        return;
-      }
-      await new Promise((resolve) => setTimeout(resolve, pollInterval));
-    }
-  } catch (error) {
-    await client.close().catch(() => {});
-    const message = error instanceof Error ? error.message : String(error);
-    console.error(`Error: Failed to stream loop logs: ${message}`);
-    process.exit(1);
-  }
-}

packages/cli/src/commands/loop/ls.ts

@@ -1,88 +0,0 @@
-import { Command } from "commander";
-import { connectToDaemon, getDaemonHost } from "../../utils/client.js";
-import type {
-  CommandOptions,
-  CommandError,
-  OutputSchema,
-  ListResult,
-} from "../../output/index.js";
-import type { LoopDaemonClient, LoopListItem } from "./types.js";
-
-interface LoopListRow {
-  id: string;
-  name: string | null;
-  status: string;
-  cwd: string;
-  updated: string;
-  activeIteration: string;
-}
-
-export interface LoopLsOptions extends CommandOptions {}
-
-export const loopLsSchema: OutputSchema<LoopListRow> = {
-  idField: "id",
-  columns: [
-    { header: "LOOP ID", field: "id", width: 10 },
-    { header: "NAME", field: "name", width: 20 },
-    { header: "STATUS", field: "status", width: 10 },
-    { header: "ITER", field: "activeIteration", width: 8 },
-    { header: "CWD", field: "cwd", width: 40 },
-    { header: "UPDATED", field: "updated", width: 24 },
-  ],
-};
-
-export function addLoopLsOptions(command: Command): Command {
-  return command.description("List loops");
-}
-
-function toRow(loop: LoopListItem): LoopListRow {
-  return {
-    id: loop.id,
-    name: loop.name,
-    status: loop.status,
-    cwd: loop.cwd,
-    updated: loop.updatedAt,
-    activeIteration: loop.activeIteration === null ? "-" : String(loop.activeIteration),
-  };
-}
-
-export type LoopLsResult = ListResult<LoopListRow>;
-
-export async function runLoopLsCommand(
-  options: LoopLsOptions,
-  _command: Command,
-): Promise<LoopLsResult> {
-  const host = getDaemonHost({ host: options.host as string | undefined });
-  let client;
-  try {
-    client = (await connectToDaemon({
-      host: options.host as string | undefined,
-    })) as unknown as LoopDaemonClient;
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    throw {
-      code: "DAEMON_NOT_RUNNING",
-      message: `Cannot connect to daemon at ${host}: ${message}`,
-      details: "Start the daemon with: paseo daemon start",
-    } satisfies CommandError;
-  }
-
-  try {
-    const payload = await client.loopList();
-    await client.close();
-    if (payload.error) {
-      throw new Error(payload.error);
-    }
-    return {
-      type: "list",
-      data: payload.loops.map(toRow),
-      schema: loopLsSchema,
-    };
-  } catch (error) {
-    await client.close().catch(() => {});
-    throw {
-      code: "LOOP_LIST_FAILED",
-      message: error instanceof Error ? error.message : String(error),
-    } satisfies CommandError;
-  }
-}

packages/cli/src/commands/loop/run.ts

@@ -1,161 +0,0 @@
-import { Command } from "commander";
-import { connectToDaemon, getDaemonHost } from "../../utils/client.js";
-import type {
-  CommandOptions,
-  CommandError,
-  OutputSchema,
-  SingleResult,
-} from "../../output/index.js";
-import { collectMultiple } from "../../utils/command-options.js";
-import { parseDuration } from "../../utils/duration.js";
-import type { LoopDaemonClient, LoopRecord, LoopRunInput } from "./types.js";
-
-export interface LoopRunRow {
-  id: string;
-  status: string;
-  name: string | null;
-  cwd: string;
-}
-
-export interface LoopRunOptions extends CommandOptions {
-  provider?: "claude" | "codex" | "opencode";
-  model?: string;
-  verifyProvider?: "claude" | "codex" | "opencode";
-  verifyModel?: string;
-  verify?: string;
-  verifyCheck?: string[];
-  archive?: boolean;
-  name?: string;
-  sleep?: string;
-  maxIterations?: string;
-  maxTime?: string;
-}
-
-export const loopRunSchema: OutputSchema<LoopRunRow> = {
-  idField: "id",
-  columns: [
-    { header: "LOOP ID", field: "id", width: 10 },
-    { header: "STATUS", field: "status", width: 10 },
-    { header: "NAME", field: "name", width: 20 },
-    { header: "CWD", field: "cwd", width: 40 },
-  ],
-};
-
-export function addLoopRunOptions(command: Command): Command {
-  return command
-    .description("Start a loop")
-    .argument("<prompt>", "Prompt for each fresh worker iteration")
-    .option("--provider <provider>", "Default provider for worker and verifier agents")
-    .option("--model <model>", "Default model for worker and verifier agents")
-    .option("--verify-provider <provider>", "Provider for the verifier agent")
-    .option("--verify-model <model>", "Model for the verifier agent")
-    .option("--verify <prompt>", "Verifier agent prompt")
-    .option(
-      "--verify-check <command>",
-      "Shell command that must exit 0 (repeatable)",
-      collectMultiple,
-      [],
-    )
-    .option("--archive", "Archive worker and verifier agents after each iteration")
-    .option("--name <name>", "Optional loop name")
-    .option("--sleep <duration>", "Delay between iterations (for example: 30s, 5m)")
-    .option("--max-iterations <n>", "Maximum number of iterations")
-    .option("--max-time <duration>", "Maximum total runtime (for example: 1h, 30m)");
-}
-
-function toRow(loop: LoopRecord): LoopRunRow {
-  return {
-    id: loop.id,
-    status: loop.status,
-    name: loop.name,
-    cwd: loop.cwd,
-  };
-}
-
-function parseMaxIterations(value: string | undefined): number | undefined {
-  if (value === undefined) {
-    return undefined;
-  }
-  const parsed = Number.parseInt(value, 10);
-  if (!Number.isInteger(parsed) || parsed <= 0) {
-    throw {
-      code: "INVALID_MAX_ITERATIONS",
-      message: "--max-iterations must be a positive integer",
-    } satisfies CommandError;
-  }
-  return parsed;
-}
-
-function buildLoopRunInput(prompt: string, options: LoopRunOptions): LoopRunInput {
-  const verifyPrompt = options.verify?.trim();
-  if (options.verify !== undefined && !verifyPrompt) {
-    throw {
-      code: "INVALID_VERIFY_PROMPT",
-      message: "--verify cannot be empty",
-    } satisfies CommandError;
-  }
-
-  return {
-    prompt,
-    cwd: process.cwd(),
-    ...(options.provider ? { provider: options.provider } : {}),
-    ...(options.model?.trim() ? { model: options.model.trim() } : {}),
-    ...(options.verifyProvider ? { verifierProvider: options.verifyProvider } : {}),
-    ...(options.verifyModel?.trim() ? { verifierModel: options.verifyModel.trim() } : {}),
-    ...(verifyPrompt ? { verifyPrompt } : {}),
-    ...(options.verifyCheck && options.verifyCheck.length > 0
-      ? { verifyChecks: options.verifyCheck }
-      : {}),
-    ...(options.archive ? { archive: true } : {}),
-    ...(options.name?.trim() ? { name: options.name.trim() } : {}),
-    ...(options.sleep ? { sleepMs: parseDuration(options.sleep) } : {}),
-    ...(options.maxIterations ? { maxIterations: parseMaxIterations(options.maxIterations) } : {}),
-    ...(options.maxTime ? { maxTimeMs: parseDuration(options.maxTime) } : {}),
-  };
-}
-
-export type LoopRunResult = SingleResult<LoopRunRow>;
-
-export async function runLoopRunCommand(
-  prompt: string,
-  options: LoopRunOptions,
-  _command: Command,
-): Promise<LoopRunResult> {
-  const host = getDaemonHost({ host: options.host as string | undefined });
-  const input = buildLoopRunInput(prompt, options);
-  let client;
-  try {
-    client = (await connectToDaemon({
-      host: options.host as string | undefined,
-    })) as unknown as LoopDaemonClient;
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    throw {
-      code: "DAEMON_NOT_RUNNING",
-      message: `Cannot connect to daemon at ${host}: ${message}`,
-      details: "Start the daemon with: paseo daemon start",
-    } satisfies CommandError;
-  }
-
-  try {
-    const payload = await client.loopRun(input);
-    await client.close();
-    if (payload.error || !payload.loop) {
-      throw new Error(payload.error ?? "Loop creation failed");
-    }
-    return {
-      type: "single",
-      data: toRow(payload.loop),
-      schema: loopRunSchema,
-    };
-  } catch (error) {
-    await client.close().catch(() => {});
-    if (error && typeof error === "object" && "code" in error) {
-      throw error;
-    }
-    throw {
-      code: "LOOP_RUN_FAILED",
-      message: error instanceof Error ? error.message : String(error),
-    } satisfies CommandError;
-  }
-}

packages/cli/src/commands/loop/stop.ts

@@ -1,80 +0,0 @@
-import { Command } from "commander";
-import { connectToDaemon, getDaemonHost } from "../../utils/client.js";
-import type {
-  CommandOptions,
-  CommandError,
-  OutputSchema,
-  SingleResult,
-} from "../../output/index.js";
-import type { LoopDaemonClient, LoopRecord } from "./types.js";
-
-interface LoopStopRow {
-  id: string;
-  status: string;
-  activeIteration: string;
-}
-
-export interface LoopStopOptions extends CommandOptions {}
-
-export const loopStopSchema: OutputSchema<LoopStopRow> = {
-  idField: "id",
-  columns: [
-    { header: "LOOP ID", field: "id", width: 10 },
-    { header: "STATUS", field: "status", width: 10 },
-    { header: "ITER", field: "activeIteration", width: 8 },
-  ],
-};
-
-export function addLoopStopOptions(command: Command): Command {
-  return command.description("Stop a running loop").argument("<id>", "Loop ID");
-}
-
-function toRow(loop: LoopRecord): LoopStopRow {
-  return {
-    id: loop.id,
-    status: loop.status,
-    activeIteration: loop.activeIteration === null ? "-" : String(loop.activeIteration),
-  };
-}
-
-export type LoopStopResult = SingleResult<LoopStopRow>;
-
-export async function runLoopStopCommand(
-  id: string,
-  options: LoopStopOptions,
-  _command: Command,
-): Promise<LoopStopResult> {
-  const host = getDaemonHost({ host: options.host as string | undefined });
-  let client;
-  try {
-    client = (await connectToDaemon({
-      host: options.host as string | undefined,
-    })) as unknown as LoopDaemonClient;
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    throw {
-      code: "DAEMON_NOT_RUNNING",
-      message: `Cannot connect to daemon at ${host}: ${message}`,
-      details: "Start the daemon with: paseo daemon start",
-    } satisfies CommandError;
-  }
-
-  try {
-    const payload = await client.loopStop(id);
-    await client.close();
-    if (payload.error || !payload.loop) {
-      throw new Error(payload.error ?? `Loop not found: ${id}`);
-    }
-    return {
-      type: "single",
-      data: toRow(payload.loop),
-      schema: loopStopSchema,
-    };
-  } catch (error) {
-    await client.close().catch(() => {});
-    throw {
-      code: "LOOP_STOP_FAILED",
-      message: error instanceof Error ? error.message : String(error),
-    } satisfies CommandError;
-  }
-}

packages/cli/src/commands/loop/types.ts

@@ -1,147 +0,0 @@
-export type LoopStatus = "running" | "succeeded" | "failed" | "stopped";
-
-export interface LoopLogEntry {
-  seq: number;
-  timestamp: string;
-  iteration: number | null;
-  source: "loop" | "worker" | "verifier" | "verify-check";
-  level: "info" | "error";
-  text: string;
-}
-
-export interface LoopVerifyCheckResult {
-  command: string;
-  exitCode: number;
-  passed: boolean;
-  stdout: string;
-  stderr: string;
-  startedAt: string;
-  completedAt: string;
-}
-
-export interface LoopVerifyPromptResult {
-  passed: boolean;
-  reason: string;
-  verifierAgentId: string | null;
-  startedAt: string;
-  completedAt: string;
-}
-
-export interface LoopIterationRecord {
-  index: number;
-  workerAgentId: string | null;
-  workerStartedAt: string;
-  workerCompletedAt: string | null;
-  verifierAgentId: string | null;
-  status: "running" | "succeeded" | "failed" | "stopped";
-  workerOutcome: "completed" | "failed" | "canceled" | null;
-  failureReason: string | null;
-  verifyChecks: LoopVerifyCheckResult[];
-  verifyPrompt: LoopVerifyPromptResult | null;
-}
-
-export interface LoopRecord {
-  id: string;
-  name: string | null;
-  prompt: string;
-  cwd: string;
-  provider: "claude" | "codex" | "opencode";
-  model: string | null;
-  workerProvider: "claude" | "codex" | "opencode" | null;
-  workerModel: string | null;
-  verifierProvider: "claude" | "codex" | "opencode" | null;
-  verifierModel: string | null;
-  verifyPrompt: string | null;
-  verifyChecks: string[];
-  archive: boolean;
-  sleepMs: number;
-  maxIterations: number | null;
-  maxTimeMs: number | null;
-  status: LoopStatus;
-  createdAt: string;
-  updatedAt: string;
-  startedAt: string;
-  completedAt: string | null;
-  stopRequestedAt: string | null;
-  iterations: LoopIterationRecord[];
-  logs: LoopLogEntry[];
-  nextLogSeq: number;
-  activeIteration: number | null;
-  activeWorkerAgentId: string | null;
-  activeVerifierAgentId: string | null;
-}
-
-export interface LoopListItem {
-  id: string;
-  name: string | null;
-  status: LoopStatus;
-  cwd: string;
-  createdAt: string;
-  updatedAt: string;
-  activeIteration: number | null;
-}
-
-export interface LoopLogsResult {
-  loop: LoopRecord;
-  entries: LoopLogEntry[];
-  nextCursor: number;
-}
-
-export interface LoopRunPayload {
-  requestId: string;
-  loop: LoopRecord | null;
-  error: string | null;
-}
-
-export interface LoopListPayload {
-  requestId: string;
-  loops: LoopListItem[];
-  error: string | null;
-}
-
-export interface LoopInspectPayload {
-  requestId: string;
-  loop: LoopRecord | null;
-  error: string | null;
-}
-
-export interface LoopLogsPayload {
-  requestId: string;
-  loop: LoopRecord | null;
-  entries: LoopLogEntry[];
-  nextCursor: number;
-  error: string | null;
-}
-
-export interface LoopStopPayload {
-  requestId: string;
-  loop: LoopRecord | null;
-  error: string | null;
-}
-
-export interface LoopRunInput {
-  prompt: string;
-  cwd: string;
-  provider?: "claude" | "codex" | "opencode";
-  model?: string;
-  workerProvider?: "claude" | "codex" | "opencode";
-  workerModel?: string;
-  verifierProvider?: "claude" | "codex" | "opencode";
-  verifierModel?: string;
-  verifyPrompt?: string;
-  verifyChecks?: string[];
-  archive?: boolean;
-  name?: string;
-  sleepMs?: number;
-  maxIterations?: number;
-  maxTimeMs?: number;
-}
-
-export interface LoopDaemonClient {
-  loopRun(input: LoopRunInput): Promise<LoopRunPayload>;
-  loopList(): Promise<LoopListPayload>;
-  loopInspect(id: string): Promise<LoopInspectPayload>;
-  loopLogs(id: string, afterSeq?: number): Promise<LoopLogsPayload>;
-  loopStop(id: string): Promise<LoopStopPayload>;
-  close(): Promise<void>;
-}

packages/cli/src/commands/schedule/create.ts

@@ -1,52 +0,0 @@
-import type { Command } from "commander";
-import type { SingleResult } from "../../output/index.js";
-import { scheduleSchema } from "./schema.js";
-import {
-  connectScheduleClient,
-  parseScheduleCreateInput,
-  toScheduleCommandError,
-  toScheduleRow,
-  type ScheduleCommandOptions,
-  type ScheduleRow,
-} from "./shared.js";
-
-export interface ScheduleCreateOptions extends ScheduleCommandOptions {
-  every?: string;
-  cron?: string;
-  name?: string;
-  target?: string;
-  maxRuns?: string;
-  expiresIn?: string;
-}
-
-export async function runCreateCommand(
-  prompt: string,
-  options: ScheduleCreateOptions,
-  _command: Command,
-): Promise<SingleResult<ScheduleRow>> {
-  const input = parseScheduleCreateInput({
-    prompt,
-    every: options.every,
-    cron: options.cron,
-    name: options.name,
-    target: options.target,
-    maxRuns: options.maxRuns,
-    expiresIn: options.expiresIn,
-  });
-  const { client } = await connectScheduleClient(options.host);
-  try {
-    const payload = await client.scheduleCreate(input);
-    if (payload.error || !payload.schedule) {
-      throw new Error(payload.error ?? "Schedule creation failed");
-    }
-    return {
-      type: "single",
-      data: toScheduleRow(payload.schedule),
-      schema: scheduleSchema,
-    };
-  } catch (error) {
-    throw toScheduleCommandError("SCHEDULE_CREATE_FAILED", "create schedule", error);
-  } finally {
-    await client.close().catch(() => {});
-  }
-}

packages/cli/src/commands/schedule/delete.ts

@@ -1,43 +0,0 @@
-import type { Command } from "commander";
-import type { SingleResult } from "../../output/index.js";
-import type { OutputSchema } from "../../output/index.js";
-import { connectScheduleClient, toScheduleCommandError, type ScheduleCommandOptions } from "./shared.js";
-
-interface ScheduleDeleteRow {
-  id: string;
-  status: string;
-}
-
-const scheduleDeleteSchema: OutputSchema<ScheduleDeleteRow> = {
-  idField: "id",
-  columns: [
-    { header: "ID", field: "id", width: 10 },
-    { header: "STATUS", field: "status", width: 12 },
-  ],
-};
-
-export async function runDeleteCommand(
-  id: string,
-  options: ScheduleCommandOptions,
-  _command: Command,
-): Promise<SingleResult<ScheduleDeleteRow>> {
-  const { client } = await connectScheduleClient(options.host);
-  try {
-    const payload = await client.scheduleDelete({ id });
-    if (payload.error) {
-      throw new Error(payload.error);
-    }
-    return {
-      type: "single",
-      data: {
-        id: payload.scheduleId,
-        status: "deleted",
-      },
-      schema: scheduleDeleteSchema,
-    };
-  } catch (error) {
-    throw toScheduleCommandError("SCHEDULE_DELETE_FAILED", "delete schedule", error);
-  } finally {
-    await client.close().catch(() => {});
-  }
-}

packages/cli/src/commands/schedule/index.ts

@@ -1,68 +0,0 @@
-import { Command } from "commander";
-import { withOutput } from "../../output/index.js";
-import { addJsonAndDaemonHostOptions } from "../../utils/command-options.js";
-import { runCreateCommand } from "./create.js";
-import { runLsCommand } from "./ls.js";
-import { runInspectCommand } from "./inspect.js";
-import { runLogsCommand } from "./logs.js";
-import { runPauseCommand } from "./pause.js";
-import { runResumeCommand } from "./resume.js";
-import { runDeleteCommand } from "./delete.js";
-
-export function createScheduleCommand(): Command {
-  const schedule = new Command("schedule").description("Manage recurring schedules");
-
-  addJsonAndDaemonHostOptions(
-    schedule
-      .command("create")
-      .description("Create a schedule")
-      .argument("<prompt>", "Prompt to run on the schedule")
-      .option("--every <duration>", "Fixed interval cadence (for example: 5m, 1h)")
-      .option("--cron <expr>", "Cron cadence expression")
-      .option("--name <name>", "Optional schedule name")
-      .option("--target <self|new-agent|agent-id>", "Run target")
-      .option("--max-runs <n>", "Maximum number of runs")
-      .option("--expires-in <duration>", "Time to live for the schedule"),
-  ).action(withOutput(runCreateCommand));
-
-  addJsonAndDaemonHostOptions(
-    schedule.command("ls").description("List schedules"),
-  ).action(withOutput(runLsCommand));
-
-  addJsonAndDaemonHostOptions(
-    schedule
-      .command("inspect")
-      .description("Inspect a schedule")
-      .argument("<id>", "Schedule ID"),
-  ).action(withOutput(runInspectCommand));
-
-  addJsonAndDaemonHostOptions(
-    schedule
-      .command("logs")
-      .description("Show recent schedule run logs")
-      .argument("<id>", "Schedule ID"),
-  ).action(withOutput(runLogsCommand));
-
-  addJsonAndDaemonHostOptions(
-    schedule
-      .command("pause")
-      .description("Pause a schedule")
-      .argument("<id>", "Schedule ID"),
-  ).action(withOutput(runPauseCommand));
-
-  addJsonAndDaemonHostOptions(
-    schedule
-      .command("resume")
-      .description("Resume a paused schedule")
-      .argument("<id>", "Schedule ID"),
-  ).action(withOutput(runResumeCommand));
-
-  addJsonAndDaemonHostOptions(
-    schedule
-      .command("delete")
-      .description("Delete a schedule")
-      .argument("<id>", "Schedule ID"),
-  ).action(withOutput(runDeleteCommand));
-
-  return schedule;
-}

packages/cli/src/commands/schedule/inspect.ts

@@ -1,32 +0,0 @@
-import type { Command } from "commander";
-import type { ListResult } from "../../output/index.js";
-import {
-  createScheduleInspectRows,
-  createScheduleInspectSchema,
-  type ScheduleInspectRow,
-} from "./schema.js";
-import { connectScheduleClient, toScheduleCommandError, type ScheduleCommandOptions } from "./shared.js";
-
-export async function runInspectCommand(
-  id: string,
-  options: ScheduleCommandOptions,
-  _command: Command,
-): Promise<ListResult<ScheduleInspectRow>> {
-  const { client } = await connectScheduleClient(options.host);
-  try {
-    const payload = await client.scheduleInspect({ id });
-    if (payload.error || !payload.schedule) {
-      throw new Error(payload.error ?? `Schedule not found: ${id}`);
-    }
-    const rows = createScheduleInspectRows(payload.schedule);
-    return {
-      type: "list",
-      data: rows,
-      schema: createScheduleInspectSchema(payload.schedule),
-    };
-  } catch (error) {
-    throw toScheduleCommandError("SCHEDULE_INSPECT_FAILED", "inspect schedule", error);
-  } finally {
-    await client.close().catch(() => {});
-  }
-}

packages/cli/src/commands/schedule/logs.ts

@@ -1,27 +0,0 @@
-import type { Command } from "commander";
-import type { ListResult } from "../../output/index.js";
-import { scheduleLogSchema, toScheduleLogRow, type ScheduleLogRow } from "./schema.js";
-import { connectScheduleClient, toScheduleCommandError, type ScheduleCommandOptions } from "./shared.js";
-
-export async function runLogsCommand(
-  id: string,
-  options: ScheduleCommandOptions,
-  _command: Command,
-): Promise<ListResult<ScheduleLogRow>> {
-  const { client } = await connectScheduleClient(options.host);
-  try {
-    const payload = await client.scheduleLogs({ id });
-    if (payload.error) {
-      throw new Error(payload.error);
-    }
-    return {
-      type: "list",
-      data: payload.runs.map(toScheduleLogRow),
-      schema: scheduleLogSchema,
-    };
-  } catch (error) {
-    throw toScheduleCommandError("SCHEDULE_LOGS_FAILED", "read schedule logs", error);
-  } finally {
-    await client.close().catch(() => {});
-  }
-}

packages/cli/src/commands/schedule/ls.ts

@@ -1,32 +0,0 @@
-import type { Command } from "commander";
-import type { ListResult } from "../../output/index.js";
-import { scheduleSchema } from "./schema.js";
-import {
-  connectScheduleClient,
-  toScheduleCommandError,
-  toScheduleRow,
-  type ScheduleCommandOptions,
-  type ScheduleRow,
-} from "./shared.js";
-
-export async function runLsCommand(
-  options: ScheduleCommandOptions,
-  _command: Command,
-): Promise<ListResult<ScheduleRow>> {
-  const { client } = await connectScheduleClient(options.host);
-  try {
-    const payload = await client.scheduleList();
-    if (payload.error) {
-      throw new Error(payload.error);
-    }
-    return {
-      type: "list",
-      data: payload.schedules.map(toScheduleRow),
-      schema: scheduleSchema,
-    };
-  } catch (error) {
-    throw toScheduleCommandError("SCHEDULE_LIST_FAILED", "list schedules", error);
-  } finally {
-    await client.close().catch(() => {});
-  }
-}

packages/cli/src/commands/schedule/pause.ts

@@ -1,33 +0,0 @@
-import type { Command } from "commander";
-import type { SingleResult } from "../../output/index.js";
-import { scheduleSchema } from "./schema.js";
-import {
-  connectScheduleClient,
-  toScheduleCommandError,
-  toScheduleRow,
-  type ScheduleCommandOptions,
-  type ScheduleRow,
-} from "./shared.js";
-
-export async function runPauseCommand(
-  id: string,
-  options: ScheduleCommandOptions,
-  _command: Command,
-): Promise<SingleResult<ScheduleRow>> {
-  const { client } = await connectScheduleClient(options.host);
-  try {
-    const payload = await client.schedulePause({ id });
-    if (payload.error || !payload.schedule) {
-      throw new Error(payload.error ?? `Failed to pause schedule: ${id}`);
-    }
-    return {
-      type: "single",
-      data: toScheduleRow(payload.schedule),
-      schema: scheduleSchema,
-    };
-  } catch (error) {
-    throw toScheduleCommandError("SCHEDULE_PAUSE_FAILED", "pause schedule", error);
-  } finally {
-    await client.close().catch(() => {});
-  }
-}

packages/cli/src/commands/schedule/resume.ts

@@ -1,33 +0,0 @@
-import type { Command } from "commander";
-import type { SingleResult } from "../../output/index.js";
-import { scheduleSchema } from "./schema.js";
-import {
-  connectScheduleClient,
-  toScheduleCommandError,
-  toScheduleRow,
-  type ScheduleCommandOptions,
-  type ScheduleRow,
-} from "./shared.js";
-
-export async function runResumeCommand(
-  id: string,
-  options: ScheduleCommandOptions,
-  _command: Command,
-): Promise<SingleResult<ScheduleRow>> {
-  const { client } = await connectScheduleClient(options.host);
-  try {
-    const payload = await client.scheduleResume({ id });
-    if (payload.error || !payload.schedule) {
-      throw new Error(payload.error ?? `Failed to resume schedule: ${id}`);
-    }
-    return {
-      type: "single",
-      data: toScheduleRow(payload.schedule),
-      schema: scheduleSchema,
-    };
-  } catch (error) {
-    throw toScheduleCommandError("SCHEDULE_RESUME_FAILED", "resume schedule", error);
-  } finally {
-    await client.close().catch(() => {});
-  }
-}

packages/cli/src/commands/schedule/schema.ts

@@ -1,88 +0,0 @@
-import type { OutputSchema } from "../../output/index.js";
-import { formatTarget, type ScheduleRow } from "./shared.js";
-import type { ScheduleRecord, ScheduleRunRecord } from "./types.js";
-
-export const scheduleSchema: OutputSchema<ScheduleRow> = {
-  idField: "id",
-  columns: [
-    { header: "ID", field: "id", width: 10 },
-    { header: "NAME", field: "name", width: 20 },
-    { header: "CADENCE", field: "cadence", width: 20 },
-    { header: "TARGET", field: "target", width: 20 },
-    { header: "STATUS", field: "status", width: 12 },
-    { header: "NEXT RUN", field: "nextRunAt", width: 24 },
-  ],
-};
-
-export interface ScheduleInspectRow {
-  key: string;
-  value: string;
-}
-
-export function createScheduleInspectSchema(record: ScheduleRecord): OutputSchema<ScheduleInspectRow> {
-  return {
-    idField: "key",
-    columns: [
-      { header: "KEY", field: "key", width: 18 },
-      { header: "VALUE", field: "value", width: 80 },
-    ],
-    serialize: () => record,
-  };
-}
-
-export interface ScheduleLogRow {
-  id: string;
-  status: string;
-  startedAt: string;
-  agentId: string | null;
-  output: string | null;
-  error: string | null;
-}
-
-export const scheduleLogSchema: OutputSchema<ScheduleLogRow> = {
-  idField: "id",
-  columns: [
-    { header: "RUN ID", field: "id", width: 14 },
-    { header: "STATUS", field: "status", width: 12 },
-    { header: "STARTED", field: "startedAt", width: 24 },
-    { header: "AGENT", field: "agentId", width: 12 },
-    { header: "OUTPUT", field: "output", width: 40 },
-    { header: "ERROR", field: "error", width: 40 },
-  ],
-};
-
-export function toScheduleLogRow(run: ScheduleRunRecord): ScheduleLogRow {
-  return {
-    id: run.id,
-    status: run.status,
-    startedAt: run.startedAt,
-    agentId: run.agentId ? run.agentId.slice(0, 7) : null,
-    output: run.output,
-    error: run.error,
-  };
-}
-
-export function createScheduleInspectRows(schedule: ScheduleRecord): ScheduleInspectRow[] {
-  return [
-    { key: "Id", value: schedule.id },
-    { key: "Name", value: schedule.name ?? "null" },
-    { key: "Prompt", value: schedule.prompt },
-    {
-      key: "Cadence",
-      value:
-        schedule.cadence.type === "cron"
-          ? `cron:${schedule.cadence.expression}`
-          : `every:${schedule.cadence.everyMs}ms`,
-    },
-    { key: "Target", value: formatTarget(schedule.target) },
-    { key: "Status", value: schedule.status },
-    { key: "CreatedAt", value: schedule.createdAt },
-    { key: "UpdatedAt", value: schedule.updatedAt },
-    { key: "NextRunAt", value: schedule.nextRunAt ?? "null" },
-    { key: "LastRunAt", value: schedule.lastRunAt ?? "null" },
-    { key: "PausedAt", value: schedule.pausedAt ?? "null" },
-    { key: "ExpiresAt", value: schedule.expiresAt ?? "null" },
-    { key: "MaxRuns", value: schedule.maxRuns == null ? "null" : `${schedule.maxRuns}` },
-    { key: "RunCount", value: `${schedule.runs.length}` },
-  ];
-}

packages/cli/src/commands/schedule/shared.ts

@@ -1,195 +0,0 @@
-import { connectToDaemon, getDaemonHost } from "../../utils/client.js";
-import type { CommandError, CommandOptions } from "../../output/index.js";
-import type {
-  CreateScheduleInput,
-  ScheduleCadence,
-  ScheduleDaemonClient,
-  ScheduleListItem,
-  ScheduleRecord,
-  ScheduleTarget,
-} from "./types.js";
-import { parseDuration } from "../../utils/duration.js";
-
-export interface ScheduleCommandOptions extends CommandOptions {
-  host?: string;
-}
-
-export async function connectScheduleClient(
-  host: string | undefined,
-): Promise<{ client: ScheduleDaemonClient; host: string }> {
-  const resolvedHost = getDaemonHost({ host });
-  try {
-    const client = (await connectToDaemon({
-      host,
-    })) as unknown as ScheduleDaemonClient;
-    return { client, host: resolvedHost };
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    throw {
-      code: "DAEMON_NOT_RUNNING",
-      message: `Cannot connect to daemon at ${resolvedHost}: ${message}`,
-      details: "Start the daemon with: paseo daemon start",
-    } satisfies CommandError;
-  }
-}
-
-export function toScheduleCommandError(
-  code: string,
-  action: string,
-  error: unknown,
-): CommandError {
-  if (error && typeof error === "object" && "code" in error) {
-    return error as CommandError;
-  }
-  const message = error instanceof Error ? error.message : String(error);
-  return {
-    code,
-    message: `Failed to ${action}: ${message}`,
-  };
-}
-
-export function formatCadence(cadence: ScheduleCadence): string {
-  if (cadence.type === "cron") {
-    return `cron:${cadence.expression}`;
-  }
-  return `every:${formatDurationMs(cadence.everyMs)}`;
-}
-
-export function formatTarget(target: ScheduleTarget | ScheduleListItem["target"]): string {
-  if (target.type === "self") {
-    return `self:${target.agentId.slice(0, 7)}`;
-  }
-  if (target.type === "agent") {
-    return `agent:${target.agentId.slice(0, 7)}`;
-  }
-  return `new-agent:${target.config.provider}`;
-}
-
-export function formatDurationMs(durationMs: number): string {
-  const parts: string[] = [];
-  let remainingMs = durationMs;
-  const hours = Math.floor(remainingMs / (60 * 60 * 1000));
-  if (hours > 0) {
-    parts.push(`${hours}h`);
-    remainingMs -= hours * 60 * 60 * 1000;
-  }
-  const minutes = Math.floor(remainingMs / (60 * 1000));
-  if (minutes > 0) {
-    parts.push(`${minutes}m`);
-    remainingMs -= minutes * 60 * 1000;
-  }
-  const seconds = Math.floor(remainingMs / 1000);
-  if (seconds > 0 || parts.length === 0) {
-    parts.push(`${seconds}s`);
-  }
-  return parts.join("");
-}
-
-export function parseScheduleCreateInput(options: {
-  prompt: string;
-  every?: string;
-  cron?: string;
-  name?: string;
-  target?: string;
-  maxRuns?: string;
-  expiresIn?: string;
-}): CreateScheduleInput {
-  const prompt = options.prompt.trim();
-  if (!prompt) {
-    throw {
-      code: "INVALID_PROMPT",
-      message: "Schedule prompt cannot be empty",
-    } satisfies CommandError;
-  }
-
-  const cadenceCount = Number(options.every !== undefined) + Number(options.cron !== undefined);
-  if (cadenceCount !== 1) {
-    throw {
-      code: "INVALID_CADENCE",
-      message: "Specify exactly one of --every or --cron",
-    } satisfies CommandError;
-  }
-
-  const cadence: ScheduleCadence = options.every
-    ? { type: "every", everyMs: parseDuration(options.every) }
-    : { type: "cron", expression: options.cron!.trim() };
-
-  const targetValue = options.target?.trim();
-  let target: ScheduleTarget;
-  if (!targetValue || targetValue === "self") {
-    const currentAgentId = process.env.PASEO_AGENT_ID?.trim();
-    if (currentAgentId) {
-      target = { type: "self", agentId: currentAgentId };
-    } else {
-      target = {
-        type: "new-agent",
-        config: {
-          provider: "claude",
-          cwd: process.cwd(),
-        },
-      };
-    }
-  } else if (targetValue === "new-agent") {
-    target = {
-      type: "new-agent",
-      config: {
-        provider: "claude",
-        cwd: process.cwd(),
-      },
-    };
-  } else {
-    target = {
-      type: "agent",
-      agentId: targetValue,
-    };
-  }
-
-  const maxRuns =
-    options.maxRuns === undefined ? undefined : parsePositiveInt(options.maxRuns, "--max-runs");
-  const expiresAt =
-    options.expiresIn === undefined
-      ? undefined
-      : new Date(Date.now() + parseDuration(options.expiresIn)).toISOString();
-
-  return {
-    prompt,
-    cadence,
-    target,
-    ...(options.name?.trim() ? { name: options.name.trim() } : {}),
-    ...(maxRuns !== undefined ? { maxRuns } : {}),
-    ...(expiresAt ? { expiresAt } : {}),
-  };
-}
-
-function parsePositiveInt(value: string, flag: string): number {
-  const parsed = Number.parseInt(value, 10);
-  if (!Number.isInteger(parsed) || parsed <= 0) {
-    throw {
-      code: "INVALID_INTEGER",
-      message: `${flag} must be a positive integer`,
-    } satisfies CommandError;
-  }
-  return parsed;
-}
-
-export interface ScheduleRow {
-  id: string;
-  name: string | null;
-  cadence: string;
-  target: string;
-  status: string;
-  nextRunAt: string | null;
-  lastRunAt: string | null;
-}
-
-export function toScheduleRow(schedule: ScheduleListItem | ScheduleRecord): ScheduleRow {
-  return {
-    id: schedule.id,
-    name: schedule.name,
-    cadence: formatCadence(schedule.cadence),
-    target: formatTarget(schedule.target),
-    status: schedule.status,
-    nextRunAt: schedule.nextRunAt,
-    lastRunAt: schedule.lastRunAt,
-  };
-}

packages/cli/src/commands/schedule/types.ts

@@ -1,141 +0,0 @@
-export type ScheduleStatus = "active" | "paused" | "completed";
-
-export type ScheduleCadence =
-  | {
-      type: "every";
-      everyMs: number;
-    }
-  | {
-      type: "cron";
-      expression: string;
-    };
-
-export type ScheduleTarget =
-  | {
-      type: "self";
-      agentId: string;
-    }
-  | {
-      type: "agent";
-      agentId: string;
-    }
-  | {
-      type: "new-agent";
-      config: {
-        provider: "claude" | "codex" | "opencode";
-        cwd: string;
-        modeId?: string;
-        model?: string;
-        thinkingOptionId?: string;
-        title?: string | null;
-        approvalPolicy?: string;
-        sandboxMode?: string;
-        networkAccess?: boolean;
-        webSearch?: boolean;
-      };
-    };
-
-export interface ScheduleRunRecord {
-  id: string;
-  scheduledFor: string;
-  startedAt: string;
-  endedAt: string | null;
-  status: "running" | "succeeded" | "failed";
-  agentId: string | null;
-  output: string | null;
-  error: string | null;
-}
-
-export interface ScheduleRecord {
-  id: string;
-  name: string | null;
-  prompt: string;
-  cadence: ScheduleCadence;
-  target: Exclude<ScheduleTarget, { type: "self" }>;
-  status: ScheduleStatus;
-  createdAt: string;
-  updatedAt: string;
-  nextRunAt: string | null;
-  lastRunAt: string | null;
-  pausedAt: string | null;
-  expiresAt: string | null;
-  maxRuns: number | null;
-  runs: ScheduleRunRecord[];
-}
-
-export interface ScheduleListItem {
-  id: string;
-  name: string | null;
-  cadence: ScheduleCadence;
-  target: Exclude<ScheduleTarget, { type: "self" }>;
-  status: ScheduleStatus;
-  nextRunAt: string | null;
-  lastRunAt: string | null;
-  createdAt: string;
-  updatedAt: string;
-  pausedAt: string | null;
-  expiresAt: string | null;
-  maxRuns: number | null;
-}
-
-export interface CreateScheduleInput {
-  prompt: string;
-  name?: string;
-  cadence: ScheduleCadence;
-  target: ScheduleTarget;
-  maxRuns?: number;
-  expiresAt?: string;
-}
-
-export interface ScheduleCreatePayload {
-  requestId: string;
-  schedule: ScheduleListItem | null;
-  error: string | null;
-}
-
-export interface ScheduleListPayload {
-  requestId: string;
-  schedules: ScheduleListItem[];
-  error: string | null;
-}
-
-export interface ScheduleInspectPayload {
-  requestId: string;
-  schedule: ScheduleRecord | null;
-  error: string | null;
-}
-
-export interface ScheduleLogsPayload {
-  requestId: string;
-  runs: ScheduleRunRecord[];
-  error: string | null;
-}
-
-export interface SchedulePausePayload {
-  requestId: string;
-  schedule: ScheduleListItem | null;
-  error: string | null;
-}
-
-export interface ScheduleResumePayload {
-  requestId: string;
-  schedule: ScheduleListItem | null;
-  error: string | null;
-}
-
-export interface ScheduleDeletePayload {
-  requestId: string;
-  scheduleId: string;
-  error: string | null;
-}
-
-export interface ScheduleDaemonClient {
-  scheduleCreate(input: CreateScheduleInput): Promise<ScheduleCreatePayload>;
-  scheduleList(): Promise<ScheduleListPayload>;
-  scheduleInspect(input: { id: string }): Promise<ScheduleInspectPayload>;
-  scheduleLogs(input: { id: string }): Promise<ScheduleLogsPayload>;
-  schedulePause(input: { id: string }): Promise<SchedulePausePayload>;
-  scheduleResume(input: { id: string }): Promise<ScheduleResumePayload>;
-  scheduleDelete(input: { id: string }): Promise<ScheduleDeletePayload>;
-  close(): Promise<void>;
-}

packages/cli/src/output/render.ts

@@ -40,9 +40,6 @@ export function render<T>(
       return renderYaml(result, opts);
     case "table":
     default:
-      if (result.schema.renderHuman) {
-        return result.schema.renderHuman(result, opts);
-      }
       return renderTable(result, opts);
   }
 }

packages/cli/src/output/types.ts

@@ -40,8 +40,6 @@ export interface OutputSchema<T> {
   idField: keyof T | ((item: T) => string);
   /** Column definitions for table output */
   columns: ColumnDef<T>[];
-  /** Optional: custom renderer for human/table output */
-  renderHuman?: (result: AnyCommandResult<T>, options: OutputOptions) => string;
   /** Optional: transform data before JSON/YAML output */
   serialize?: (data: T) => unknown;
 }

packages/cli/tests/02-output.test.ts

@@ -29,17 +29,6 @@ interface Agent {
   provider: string;
 }
 
-interface ChatMessage {
-  id: string;
-  author: string;
-  authorName: string | null;
-  createdAt: string;
-  replyTo: string;
-  mentionAgentIds: string[];
-  mentionLabels: string[];
-  body: string;
-}
-
 // Schema for agents
 const agentSchema: OutputSchema<Agent> = {
   idField: "id",
@@ -222,36 +211,6 @@ test("render uses table format by default", () => {
   assert.ok(output.includes("ID"), "Should use table format with headers");
 });
 
-test("render uses custom human renderer when provided", () => {
-  const chatSchema: OutputSchema<ChatMessage> = {
-    idField: "id",
-    columns: [{ header: "ID", field: "id" }],
-    renderHuman: (result) => {
-      const data = result.type === "list" ? result.data : [result.data];
-      return data.map((message) => `msg ${message.id}: ${message.body}`).join("\n");
-    },
-  };
-  const chatResult: ListResult<ChatMessage> = {
-    type: "list",
-    data: [
-      {
-        id: "m1",
-        author: "agent-1",
-        authorName: "Planner",
-        createdAt: "2026-03-29T10:00:00Z",
-        replyTo: "-",
-        mentionAgentIds: [],
-        mentionLabels: [],
-        body: "hello",
-      },
-    ],
-    schema: chatSchema,
-  };
-
-  const output = render(chatResult, { noColor: true });
-  assert.strictEqual(output, "msg m1: hello", "Should use custom human renderer");
-});
-
 test("render uses json format when specified", () => {
   const output = render(listResult, { format: "json" });
   const parsed = JSON.parse(output);

packages/cli/tests/15-provider.test.ts

@@ -31,6 +31,11 @@ type ProviderModel = {
 };
 
 const EXPECTED_CLAUDE_MODELS = [
+  {
+    id: "claude-sonnet-4-5-20250929",
+    model: "Sonnet 4.5",
+    descriptionFragment: "Best for everyday tasks",
+  },
   {
     id: "claude-sonnet-4-6",
     model: "Sonnet 4.6",
@@ -42,7 +47,7 @@ const EXPECTED_CLAUDE_MODELS = [
     descriptionFragment: "Most capable",
   },
   {
-    id: "claude-haiku-4-5",
+    id: "claude-haiku-4-5-20251001",
     model: "Haiku 4.5",
     descriptionFragment: "Fastest",
   },
@@ -202,13 +207,10 @@ try {
       ids.includes("opencode/gpt-5-nano"),
       "opencode output should include opencode/gpt-5-nano",
     );
+    assert(ids.includes("openai/o3-mini"), "opencode output should include openai/o3-mini");
     assert(
-      ids.some((id) => id.startsWith("openrouter/openai/")),
-      "opencode output should include OpenRouter OpenAI models",
-    );
-    assert(
-      ids.includes("openrouter/openai/gpt-5.3-codex"),
-      "opencode output should include openrouter/openai/gpt-5.3-codex",
+      ids.includes("openai/gpt-5.3-codex-spark"),
+      "opencode output should include openai/gpt-5.3-codex-spark",
     );
     console.log("✓ provider models opencode returns namespaced model IDs\n");
   }
@@ -267,8 +269,8 @@ try {
       "--quiet should print the current Claude catalog IDs",
     );
     assert(
-      claudeModelsFromJson.some((m) => m.id === "claude-sonnet-4-6"),
-      "captured --json output should include the current Claude everyday model id",
+      claudeModelsFromJson.some((m) => m.id === "claude-sonnet-4-5-20250929"),
+      "captured --json output should still include the Claude default model id",
     );
     console.log("✓ provider models --quiet outputs model IDs only\n");
   }

packages/cli/tests/30-chat.test.ts

@@ -1,85 +0,0 @@
-#!/usr/bin/env npx tsx
-
-import assert from "node:assert";
-import { rm } from "node:fs/promises";
-import { createE2ETestContext } from "./helpers/test-daemon.ts";
-
-console.log("=== Chat Command Tests ===\n");
-
-const ctx = await createE2ETestContext({ timeout: 30000 });
-
-try {
-  {
-    console.log("Test 1: chat create/ls/inspect work");
-    const created = await ctx.paseo(["chat", "create", "coord-room", "--purpose", "Coordination"]);
-    assert.strictEqual(created.exitCode, 0, created.stderr);
-    assert(created.stdout.includes("coord-room"), created.stdout);
-
-    const listed = await ctx.paseo(["chat", "ls"]);
-    assert.strictEqual(listed.exitCode, 0, listed.stderr);
-    assert(listed.stdout.includes("coord-room"), listed.stdout);
-
-    const inspected = await ctx.paseo(["chat", "inspect", "coord-room"]);
-    assert.strictEqual(inspected.exitCode, 0, inspected.stderr);
-    assert(inspected.stdout.includes("Coordination"), inspected.stdout);
-    console.log("chat create/ls/inspect work\n");
-  }
-
-  {
-    console.log("Test 2: chat post/read/wait work");
-    const posted = await ctx.paseo([
-      "chat",
-      "post",
-      "coord-room",
-      "first message for @agent-1",
-    ], {
-      env: { PASEO_AGENT_ID: "00000000-0000-4000-8000-000000000111" },
-    });
-    assert.strictEqual(posted.exitCode, 0, posted.stderr);
-    assert(posted.stdout.includes("first message"), posted.stdout);
-    assert(posted.stdout.includes("00000000-0000-4000-8000-000000000111"), posted.stdout);
-
-    const read = await ctx.paseo(["chat", "read", "coord-room", "--limit", "10"]);
-    assert.strictEqual(read.exitCode, 0, read.stderr);
-    assert(read.stdout.includes("first message"), read.stdout);
-    assert(read.stdout.includes("00000000-0000-4000-8000-000000000111"), read.stdout);
-
-    const readJson = await ctx.paseo(["chat", "read", "coord-room", "--limit", "10", "--json"]);
-    assert.strictEqual(readJson.exitCode, 0, readJson.stderr);
-    const readPayload = JSON.parse(readJson.stdout);
-    assert.strictEqual(readPayload[0]?.author, "00000000-0000-4000-8000-000000000111");
-
-    const waitPromise = ctx.paseo(["chat", "wait", "coord-room", "--timeout", "5s"]);
-    await new Promise((resolve) => setTimeout(resolve, 250));
-    const secondPost = await ctx.paseo(["chat", "post", "coord-room", "second message"]);
-    assert.strictEqual(secondPost.exitCode, 0, secondPost.stderr);
-
-    const waited = await waitPromise;
-    assert.strictEqual(waited.exitCode, 0, waited.stderr);
-    assert(waited.stdout.includes("second message"), waited.stdout);
-    console.log("chat post/read/wait work\n");
-  }
-
-  {
-    console.log("Test 3: duplicate room create fails");
-    const duplicate = await ctx.paseo(["chat", "create", "coord-room"]);
-    assert.notStrictEqual(duplicate.exitCode, 0, "duplicate create should fail");
-    const combined = `${duplicate.stdout}\n${duplicate.stderr}`;
-    assert(combined.toLowerCase().includes("already exists"), combined);
-    console.log("duplicate room create fails\n");
-  }
-
-  {
-    console.log("Test 4: chat delete works");
-    const deleted = await ctx.paseo(["chat", "delete", "coord-room"]);
-    assert.strictEqual(deleted.exitCode, 0, deleted.stderr);
-    assert(deleted.stdout.includes("coord-room"), deleted.stdout);
-    console.log("chat delete works\n");
-  }
-} finally {
-  await ctx.stop();
-  await rm(ctx.paseoHome, { recursive: true, force: true });
-  await rm(ctx.workDir, { recursive: true, force: true });
-}
-
-console.log("=== Chat Command Tests Passed ===");

packages/cli/tests/31-loop-schedule.test.ts

@@ -1,99 +0,0 @@
-#!/usr/bin/env npx tsx
-
-import assert from "node:assert";
-import { rm } from "node:fs/promises";
-import { createE2ETestContext } from "./helpers/test-daemon.ts";
-
-function sleep(ms: number): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-console.log("=== Loop And Schedule Command Tests ===\n");
-
-const ctx = await createE2ETestContext({ timeout: 30000 });
-
-try {
-  {
-    console.log("Test 1: schedule create/ls/inspect/pause/resume/delete work");
-    const created = await ctx.paseo(
-      ["schedule", "create", "Review new PRs", "--every", "5m", "--name", "review-prs", "--json"],
-      { timeout: 30000 },
-    );
-    assert.strictEqual(created.exitCode, 0, created.stderr);
-    const createdJson = JSON.parse(created.stdout);
-    assert.strictEqual(createdJson.name, "review-prs");
-    assert.strictEqual(createdJson.cadence, "every:5m");
-
-    const listed = await ctx.paseo(["schedule", "ls", "--json"]);
-    assert.strictEqual(listed.exitCode, 0, listed.stderr);
-    const listedJson = JSON.parse(listed.stdout);
-    assert(Array.isArray(listedJson), listed.stdout);
-    assert(listedJson.some((item: { id: string }) => item.id === createdJson.id), listed.stdout);
-
-    const inspected = await ctx.paseo(["schedule", "inspect", createdJson.id, "--json"]);
-    assert.strictEqual(inspected.exitCode, 0, inspected.stderr);
-    const inspectedJson = JSON.parse(inspected.stdout);
-    assert.strictEqual(inspectedJson.status, "active");
-    assert.strictEqual(inspectedJson.prompt, "Review new PRs");
-
-    const paused = await ctx.paseo(["schedule", "pause", createdJson.id, "--json"]);
-    assert.strictEqual(paused.exitCode, 0, paused.stderr);
-    assert.strictEqual(JSON.parse(paused.stdout).status, "paused");
-
-    const resumed = await ctx.paseo(["schedule", "resume", createdJson.id, "--json"]);
-    assert.strictEqual(resumed.exitCode, 0, resumed.stderr);
-    assert.strictEqual(JSON.parse(resumed.stdout).status, "active");
-
-    const deleted = await ctx.paseo(["schedule", "delete", createdJson.id, "--json"]);
-    assert.strictEqual(deleted.exitCode, 0, deleted.stderr);
-    assert.strictEqual(JSON.parse(deleted.stdout).id, createdJson.id);
-    console.log("schedule commands work\n");
-  }
-
-  {
-    console.log("Test 2: loop run/ls/inspect/logs/stop work");
-    const run = await ctx.paseo(
-      ["loop", "run", "Return any response", "--name", "smoke-loop", "--verify-check", "true", "--json"],
-      { timeout: 30000 },
-    );
-    assert.strictEqual(run.exitCode, 0, run.stderr);
-    const runJson = JSON.parse(run.stdout);
-    assert.strictEqual(runJson.name, "smoke-loop");
-
-    const listed = await ctx.paseo(["loop", "ls", "--json"]);
-    assert.strictEqual(listed.exitCode, 0, listed.stderr);
-    const listedJson = JSON.parse(listed.stdout);
-    assert(Array.isArray(listedJson), listed.stdout);
-    assert(listedJson.some((item: { id: string }) => item.id === runJson.id), listed.stdout);
-
-    let status = "running";
-    for (let attempt = 0; attempt < 40; attempt += 1) {
-      const inspect = await ctx.paseo(["loop", "inspect", runJson.id, "--json"]);
-      assert.strictEqual(inspect.exitCode, 0, inspect.stderr);
-      const inspectJson = JSON.parse(inspect.stdout);
-      status = inspectJson.status;
-      if (status !== "running") {
-        assert.strictEqual(status, "succeeded", inspect.stdout);
-        break;
-      }
-      await sleep(250);
-    }
-    assert.strictEqual(status, "succeeded");
-
-    const logs = await ctx.paseo(["loop", "logs", runJson.id], { timeout: 15000 });
-    assert.strictEqual(logs.exitCode, 0, logs.stderr);
-    assert(logs.stdout.includes("verify-check"), logs.stdout);
-
-    const stopped = await ctx.paseo(["loop", "stop", runJson.id, "--json"]);
-    assert.strictEqual(stopped.exitCode, 0, stopped.stderr);
-    const stoppedJson = JSON.parse(stopped.stdout);
-    assert(["succeeded", "stopped"].includes(stoppedJson.status), stopped.stdout);
-    console.log("loop commands work\n");
-  }
-} finally {
-  await ctx.stop();
-  await rm(ctx.paseoHome, { recursive: true, force: true });
-  await rm(ctx.workDir, { recursive: true, force: true });
-}
-
-console.log("=== Loop And Schedule Command Tests Passed ===");

packages/cli/tests/helpers/test-daemon.ts

@@ -333,7 +333,6 @@ export async function runPaseoCli(
   options?: {
     timeout?: number;
     cwd?: string;
-    env?: NodeJS.ProcessEnv;
   },
 ): Promise<{ exitCode: number; stdout: string; stderr: string }> {
   const timeout = options?.timeout ?? 60000;
@@ -349,7 +348,6 @@ export async function runPaseoCli(
         ...TEST_DAEMON_ENV_DEFAULTS,
         PASEO_HOST: `${TEST_DAEMON_HOST}:${ctx.port}`,
         PASEO_HOME: ctx.paseoHome,
-        ...options?.env,
       },
       cwd,
       stdio: ["ignore", "pipe", "pipe"],
@@ -401,7 +399,7 @@ export async function createE2ETestContext(options?: { timeout?: number }): Prom
     /** Run a paseo CLI command against this daemon */
     paseo: (
       args: string[],
-      opts?: { timeout?: number; cwd?: string; env?: NodeJS.ProcessEnv },
+      opts?: { timeout?: number; cwd?: string },
     ) => Promise<{
       exitCode: number;
       stdout: string;
@@ -411,7 +409,7 @@ export async function createE2ETestContext(options?: { timeout?: number }): Prom
 > {
   const ctx = await startTestDaemon({ timeout: options?.timeout });
 
-  const paseo = (args: string[], opts?: { timeout?: number; cwd?: string; env?: NodeJS.ProcessEnv }) =>
+  const paseo = (args: string[], opts?: { timeout?: number; cwd?: string }) =>
     runPaseoCli(ctx, args, opts);
 
   return {

packages/desktop/src/daemon/daemon-manager.ts

@@ -2,7 +2,6 @@ import { spawn, type ChildProcess } from "node:child_process";
 import { existsSync, readFileSync } from "node:fs";
 import path from "node:path";
 import { app, ipcMain } from "electron";
-import log from "electron-log/main";
 import { loadConfig, resolvePaseoHome, getOrCreateServerId } from "@getpaseo/server";
 import {
   copyAttachmentFileToManagedStorage,
@@ -141,13 +140,6 @@ function tailFile(filePath: string, lines = 50): string {
   }
 }
 
-function logDesktopDaemonLifecycle(message: string, details?: Record<string, unknown>): void {
-  log.info("[desktop daemon]", message, {
-    pid: process.pid,
-    ...(details ?? {}),
-  });
-}
-
 function buildDesktopDaemonCorsOriginsEnv(): string | undefined {
   const origins = new Set(
     (process.env.PASEO_CORS_ORIGINS ?? "")
@@ -311,16 +303,6 @@ async function startDaemon(): Promise<DesktopDaemonStatus> {
     },
   });
 
-  logDesktopDaemonLifecycle("starting detached daemon", {
-    appIsPackaged: app.isPackaged,
-    daemonRunnerEntry: daemonRunner.entryPath,
-    daemonRunnerExecArgv: daemonRunner.execArgv,
-    command: invocation.command,
-    args: invocation.args,
-    listen: process.env.PASEO_LISTEN ?? null,
-    corsOrigins: corsOrigins ?? null,
-  });
-
   const child: ChildProcess = spawn(
     invocation.command,
     invocation.args,
@@ -331,12 +313,6 @@ async function startDaemon(): Promise<DesktopDaemonStatus> {
     },
   );
 
-  logDesktopDaemonLifecycle("detached spawn returned", {
-    childPid: child.pid ?? null,
-    spawnfile: child.spawnfile,
-    spawnargs: child.spawnargs,
-  });
-
   child.unref();
 
   // Wait for process to survive the grace period
@@ -351,26 +327,15 @@ async function startDaemon(): Promise<DesktopDaemonStatus> {
     const timer = setTimeout(() => finish(false), DETACHED_STARTUP_GRACE_MS);
 
     child.once("error", () => {
-      logDesktopDaemonLifecycle("detached child emitted error during grace period", {
-        childPid: child.pid ?? null,
-      });
       clearTimeout(timer);
       finish(true);
     });
     child.once("exit", () => {
-      logDesktopDaemonLifecycle("detached child emitted exit during grace period", {
-        childPid: child.pid ?? null,
-      });
       clearTimeout(timer);
       finish(true);
     });
   });
 
-  logDesktopDaemonLifecycle("detached startup grace period completed", {
-    childPid: child.pid ?? null,
-    exitedEarly,
-  });
-
   if (exitedEarly) {
     const logs = tailFile(logFilePath(), 15);
     throw new Error(`Daemon failed to start.${logs ? `\n\nRecent logs:\n${logs}` : ""}`);
@@ -379,15 +344,6 @@ async function startDaemon(): Promise<DesktopDaemonStatus> {
   // Poll for PID file with server ID
   for (let attempt = 0; attempt < STARTUP_POLL_MAX_ATTEMPTS; attempt++) {
     const status = resolveStatus();
-    if (attempt === 0 || attempt === STARTUP_POLL_MAX_ATTEMPTS - 1 || attempt % 10 === 9) {
-      logDesktopDaemonLifecycle("polling daemon status after detached start", {
-        attempt: attempt + 1,
-        status: status.status,
-        pid: status.pid,
-        listen: status.listen,
-        serverId: status.serverId || null,
-      });
-    }
     if (status.status === "running" && status.serverId) return status;
     await sleep(STARTUP_POLL_INTERVAL_MS);
   }

packages/desktop/src/features/menu.ts

@@ -1,9 +1,4 @@
-import { app, Menu, BrowserWindow, ipcMain } from "electron";
-
-type ShowContextMenuInput = {
-  kind?: "terminal";
-  hasSelection?: boolean;
-};
+import { app, Menu, BrowserWindow } from "electron";
 
 function withBrowserWindow(
   callback: (win: BrowserWindow) => void,
@@ -94,36 +89,4 @@ export function setupApplicationMenu(): void {
 
   const menu = Menu.buildFromTemplate(template);
   Menu.setApplicationMenu(menu);
-
-  ipcMain.handle("paseo:menu:showContextMenu", (event, input?: ShowContextMenuInput) => {
-    const win = BrowserWindow.fromWebContents(event.sender);
-    if (!win) {
-      return;
-    }
-
-    if (input?.kind !== "terminal") {
-      return;
-    }
-
-    const menu = Menu.buildFromTemplate([
-      {
-        label: "Copy",
-        role: "copy",
-        enabled: input.hasSelection === true,
-      },
-      {
-        label: "Paste",
-        role: "paste",
-      },
-      {
-        type: "separator",
-      },
-      {
-        label: "Select All",
-        role: "selectAll",
-      },
-    ]);
-
-    menu.popup({ window: win });
-  });
 }

packages/desktop/src/main.ts

@@ -13,8 +13,6 @@ import {
 import { closeAllTransportSessions } from "./daemon/local-transport.js";
 import {
   registerWindowManager,
-  getTitleBarOverlayOptions,
-  resolveSystemWindowTheme,
   setupWindowResizeEvents,
   setupDragDropPrevention,
 } from "./window/window-manager.js";
@@ -98,7 +96,11 @@ async function createMainWindow(): Promise<void> {
     ...(isMac
       ? { trafficLightPosition: { x: 16, y: 14 } }
       : {
-          titleBarOverlay: getTitleBarOverlayOptions(resolveSystemWindowTheme()),
+          titleBarOverlay: {
+            color: "#18181c",
+            symbolColor: "#e4e4e7",
+            height: 48,
+          },
           autoHideMenuBar: true,
         }),
     webPreferences: {
@@ -110,6 +112,7 @@ async function createMainWindow(): Promise<void> {
 
   setupWindowResizeEvents(mainWindow);
   setupDragDropPrevention(mainWindow);
+
   mainWindow.once("ready-to-show", () => {
     mainWindow.show();
   });

packages/desktop/src/preload.ts

@@ -1,3 +1,4 @@
+import "electron-log/preload";
 import { contextBridge, ipcRenderer } from "electron";
 
 type EventHandler = (payload: unknown) => void;
@@ -26,8 +27,6 @@ contextBridge.exposeInMainWorld("paseoDesktop", {
       endMove: () => ipcRenderer.send("paseo:window:endMove"),
       toggleMaximize: () => ipcRenderer.invoke("paseo:window:toggleMaximize"),
       isFullscreen: () => ipcRenderer.invoke("paseo:window:isFullscreen"),
-      setTitleBarTheme: (theme: "light" | "dark") =>
-        ipcRenderer.invoke("paseo:window:setTitleBarTheme", theme),
       onResized: (handler: EventHandler): (() => void) => {
         const listener = (_ipcEvent: Electron.IpcRendererEvent, payload: unknown) => {
           handler(payload);
@@ -53,8 +52,4 @@ contextBridge.exposeInMainWorld("paseoDesktop", {
   opener: {
     openUrl: (url: string) => ipcRenderer.invoke("paseo:opener:openUrl", url),
   },
-  menu: {
-    showContextMenu: (input?: Record<string, unknown>) =>
-      ipcRenderer.invoke("paseo:menu:showContextMenu", input),
-  },
 });

packages/desktop/src/window/window-manager.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, it } from "vitest";
 
-import { getTitleBarOverlayOptions, readBadgeCount, readWindowTheme } from "./window-manager";
+import { readBadgeCount } from "./window-manager";
 
 describe("window-manager", () => {
   describe("readBadgeCount", () => {
@@ -20,35 +20,4 @@ describe("window-manager", () => {
       expect(readBadgeCount({ count: 2 })).toBe(0);
     });
   });
-
-  describe("readWindowTheme", () => {
-    it("accepts supported title bar themes", () => {
-      expect(readWindowTheme("light")).toBe("light");
-      expect(readWindowTheme("dark")).toBe("dark");
-    });
-
-    it("rejects invalid title bar themes", () => {
-      expect(readWindowTheme(undefined)).toBeNull();
-      expect(readWindowTheme("auto")).toBeNull();
-      expect(readWindowTheme("system")).toBeNull();
-    });
-  });
-
-  describe("getTitleBarOverlayOptions", () => {
-    it("returns light title bar overlay colors", () => {
-      expect(getTitleBarOverlayOptions("light")).toEqual({
-        color: "#ffffff",
-        symbolColor: "#09090b",
-        height: 48,
-      });
-    });
-
-    it("returns dark title bar overlay colors", () => {
-      expect(getTitleBarOverlayOptions("dark")).toEqual({
-        color: "#18181c",
-        symbolColor: "#e4e4e7",
-        height: 48,
-      });
-    });
-  });
 });

packages/desktop/src/window/window-manager.ts

@@ -1,4 +1,4 @@
-import { app, BrowserWindow, ipcMain, nativeTheme } from "electron";
+import { app, BrowserWindow, ipcMain } from "electron";
 import {
   createWindowMoveState,
   readWindowMovePayload,
@@ -14,28 +14,6 @@ export function readBadgeCount(input: unknown): number {
   return input;
 }
 
-export type WindowTheme = "light" | "dark";
-
-export function readWindowTheme(input: unknown): WindowTheme | null {
-  if (input === "light" || input === "dark") {
-    return input;
-  }
-
-  return null;
-}
-
-export function resolveSystemWindowTheme(): WindowTheme {
-  return nativeTheme.shouldUseDarkColors ? "dark" : "light";
-}
-
-export function getTitleBarOverlayOptions(theme: WindowTheme): Electron.TitleBarOverlayOptions {
-  if (theme === "dark") {
-    return { color: "#18181c", symbolColor: "#e4e4e7", height: 48 };
-  }
-
-  return { color: "#ffffff", symbolColor: "#09090b", height: 48 };
-}
-
 export function registerWindowManager(): void {
   // ---------------------------------------------------------------------------
   // Manual window dragging (replaces flaky CSS -webkit-app-region: drag).
@@ -123,20 +101,6 @@ export function registerWindowManager(): void {
       }
     }
   });
-
-  ipcMain.handle("paseo:window:setTitleBarTheme", (event, theme?: unknown) => {
-    const win = BrowserWindow.fromWebContents(event.sender);
-    if (!win || process.platform === "darwin") {
-      return;
-    }
-
-    const nextTheme = readWindowTheme(theme);
-    if (!nextTheme) {
-      return;
-    }
-
-    win.setTitleBarOverlay(getTitleBarOverlayOptions(nextTheme));
-  });
 }
 
 export function setupWindowResizeEvents(win: BrowserWindow): void {

packages/server/package.json

@@ -65,7 +65,6 @@
     "@deepgram/sdk": "^3.4.0",
     "@getpaseo/highlight": "0.1.37",
     "@getpaseo/relay": "0.1.37",
-    "@isaacs/ttlcache": "^2.1.4",
     "@modelcontextprotocol/sdk": "^1.20.1",
     "@opencode-ai/sdk": "1.2.6",
     "@sctg/sentencepiece-js": "^1.1.0",

packages/server/scripts/daemon-runner.ts

@@ -1,6 +1,5 @@
 import { fileURLToPath } from "url";
 import { existsSync } from "node:fs";
-import path from "node:path";
 import { loadConfig } from "../src/server/config.js";
 import { acquirePidLock, PidLockError, releasePidLock } from "../src/server/pid-lock.js";
 import { resolvePaseoHome } from "../src/server/paseo-home.js";
@@ -56,30 +55,13 @@ function resolveWorkerExecArgv(workerEntry: string): string[] {
   return workerEntry.endsWith(".ts") ? ["--import", "tsx"] : [];
 }
 
-function resolvePackagedNodeEntrypointRunnerPath(currentScriptPath: string): string | null {
-  const packageMarker = `${path.sep}node_modules${path.sep}@getpaseo${path.sep}server${path.sep}`;
-  const markerIndex = currentScriptPath.lastIndexOf(packageMarker);
-  if (markerIndex === -1) {
-    return null;
-  }
-
-  const appRoot = currentScriptPath.slice(0, markerIndex);
-  const runnerPath = path.join(appRoot, "dist", "daemon", "node-entrypoint-runner.js");
-  return existsSync(runnerPath) ? runnerPath : null;
-}
-
 async function main(): Promise<void> {
   const config = parseConfig(process.argv.slice(2));
   const workerEntry = config.devMode ? resolveDevWorkerEntry() : resolveWorkerEntry();
-  const workerExecArgv = resolveWorkerExecArgv(workerEntry);
   const workerEnv: NodeJS.ProcessEnv = {
     ...process.env,
     PASEO_PID_LOCK_MODE: "external",
   };
-  const packagedNodeEntrypointRunner =
-    process.env.ELECTRON_RUN_AS_NODE === "1"
-      ? resolvePackagedNodeEntrypointRunnerPath(fileURLToPath(import.meta.url))
-      : null;
 
   applySherpaLoaderEnv(workerEnv);
 
@@ -118,22 +100,7 @@ async function main(): Promise<void> {
     resolveWorkerEntry: () => workerEntry,
     workerArgs: config.workerArgs,
     workerEnv,
-    workerExecArgv,
-    resolveWorkerSpawnSpec: packagedNodeEntrypointRunner
-      ? (resolvedWorkerEntry) => ({
-          command: process.execPath,
-          args: [
-            packagedNodeEntrypointRunner,
-            "node-script",
-            resolvedWorkerEntry,
-            ...config.workerArgs,
-          ],
-          env: {
-            ...workerEnv,
-            ELECTRON_RUN_AS_NODE: "1",
-          },
-        })
-      : undefined,
+    workerExecArgv: resolveWorkerExecArgv(workerEntry),
     restartOnCrash: config.devMode,
     onSupervisorExit: releaseLock,
   });

packages/server/scripts/supervisor.ts

@@ -1,4 +1,4 @@
-import { fork, spawn, type ChildProcess } from "child_process";
+import { fork, type ChildProcess } from "child_process";
 
 type WorkerLifecycleMessage =
   | {
@@ -16,11 +16,6 @@ type SupervisorOptions = {
   workerArgs?: string[];
   workerEnv?: NodeJS.ProcessEnv;
   workerExecArgv?: string[];
-  resolveWorkerSpawnSpec?: (workerEntry: string) => {
-    command: string;
-    args: string[];
-    env?: NodeJS.ProcessEnv;
-  } | null;
   restartOnCrash?: boolean;
   onSupervisorExit?: () => Promise<void> | void;
 };
@@ -52,7 +47,6 @@ export function runSupervisor(options: SupervisorOptions): void {
   const workerArgs = options.workerArgs ?? process.argv.slice(2);
   const workerEnv = options.workerEnv ?? process.env;
   const workerExecArgv = options.workerExecArgv ?? ["--import", "tsx"];
-  const resolveWorkerSpawnSpec = options.resolveWorkerSpawnSpec;
 
   let child: ChildProcess | null = null;
   let restarting = false;
@@ -90,19 +84,11 @@ export function runSupervisor(options: SupervisorOptions): void {
       return;
     }
 
-    const spawnSpec = resolveWorkerSpawnSpec?.(workerEntry) ?? null;
-    if (spawnSpec) {
-      child = spawn(spawnSpec.command, spawnSpec.args, {
-        stdio: ["inherit", "inherit", "inherit", "ipc"],
-        env: spawnSpec.env ?? workerEnv,
-      });
-    } else {
-      child = fork(workerEntry, workerArgs, {
-        stdio: "inherit",
-        env: workerEnv,
-        execArgv: workerExecArgv,
-      });
-    }
+    child = fork(workerEntry, workerArgs, {
+      stdio: "inherit",
+      env: workerEnv,
+      execArgv: workerExecArgv,
+    });
 
     child.on("message", (msg: unknown) => {
       const lifecycleMessage = parseLifecycleMessage(msg);

packages/server/src/client/daemon-client.ts

@@ -241,82 +241,6 @@ type ListTerminalsPayload = ListTerminalsResponse["payload"];
 type CreateTerminalPayload = CreateTerminalResponse["payload"];
 type SubscribeTerminalPayload = SubscribeTerminalResponse["payload"];
 type KillTerminalPayload = KillTerminalResponse["payload"];
-type ChatCreatePayload = Extract<
-  SessionOutboundMessage,
-  { type: "chat/create/response" }
->["payload"];
-type ChatListPayload = Extract<
-  SessionOutboundMessage,
-  { type: "chat/list/response" }
->["payload"];
-type ChatInspectPayload = Extract<
-  SessionOutboundMessage,
-  { type: "chat/inspect/response" }
->["payload"];
-type ChatDeletePayload = Extract<
-  SessionOutboundMessage,
-  { type: "chat/delete/response" }
->["payload"];
-type ChatPostPayload = Extract<
-  SessionOutboundMessage,
-  { type: "chat/post/response" }
->["payload"];
-type ChatReadPayload = Extract<
-  SessionOutboundMessage,
-  { type: "chat/read/response" }
->["payload"];
-type ChatWaitPayload = Extract<
-  SessionOutboundMessage,
-  { type: "chat/wait/response" }
->["payload"];
-type LoopRunPayload = Extract<
-  SessionOutboundMessage,
-  { type: "loop/run/response" }
->["payload"];
-type LoopListPayload = Extract<
-  SessionOutboundMessage,
-  { type: "loop/list/response" }
->["payload"];
-type LoopInspectPayload = Extract<
-  SessionOutboundMessage,
-  { type: "loop/inspect/response" }
->["payload"];
-type LoopLogsPayload = Extract<
-  SessionOutboundMessage,
-  { type: "loop/logs/response" }
->["payload"];
-type LoopStopPayload = Extract<
-  SessionOutboundMessage,
-  { type: "loop/stop/response" }
->["payload"];
-type ScheduleCreatePayload = Extract<
-  SessionOutboundMessage,
-  { type: "schedule/create/response" }
->["payload"];
-type ScheduleListPayload = Extract<
-  SessionOutboundMessage,
-  { type: "schedule/list/response" }
->["payload"];
-type ScheduleInspectPayload = Extract<
-  SessionOutboundMessage,
-  { type: "schedule/inspect/response" }
->["payload"];
-type ScheduleLogsPayload = Extract<
-  SessionOutboundMessage,
-  { type: "schedule/logs/response" }
->["payload"];
-type SchedulePausePayload = Extract<
-  SessionOutboundMessage,
-  { type: "schedule/pause/response" }
->["payload"];
-type ScheduleResumePayload = Extract<
-  SessionOutboundMessage,
-  { type: "schedule/resume/response" }
->["payload"];
-type ScheduleDeletePayload = Extract<
-  SessionOutboundMessage,
-  { type: "schedule/delete/response" }
->["payload"];
 export type FetchAgentTimelinePayload = FetchAgentTimelineResponseMessage["payload"];
 
 export type FetchAgentTimelineDirection = FetchAgentTimelinePayload["direction"];
@@ -353,110 +277,6 @@ export type FetchWorkspacesOptions = Omit<FetchWorkspacesRequest, "type" | "requ
 };
 export type FetchWorkspacesEntry = FetchWorkspacesPayload["entries"][number];
 export type FetchWorkspacesPageInfo = FetchWorkspacesPayload["pageInfo"];
-export type CreateChatRoomOptions = {
-  name: string;
-  purpose?: string | null;
-  requestId?: string;
-};
-export type InspectChatRoomOptions = {
-  room: string;
-  requestId?: string;
-};
-export type DeleteChatRoomOptions = {
-  room: string;
-  requestId?: string;
-};
-export type PostChatMessageOptions = {
-  room: string;
-  body: string;
-  authorAgentId?: string;
-  replyToMessageId?: string | null;
-  requestId?: string;
-};
-export type ReadChatMessagesOptions = {
-  room: string;
-  limit?: number;
-  since?: string;
-  authorAgentId?: string;
-  requestId?: string;
-};
-export type WaitForChatMessagesOptions = {
-  room: string;
-  afterMessageId?: string | null;
-  timeoutMs?: number;
-  requestId?: string;
-};
-export type RunLoopOptions = {
-  prompt: string;
-  cwd: string;
-  verifyPrompt?: string | null;
-  verifyChecks?: string[];
-  name?: string | null;
-  sleepMs?: number;
-  maxIterations?: number;
-  maxTimeMs?: number;
-  requestId?: string;
-};
-export type InspectLoopOptions = {
-  id: string;
-  requestId?: string;
-};
-export type LoopLogsOptions = {
-  id: string;
-  afterSeq?: number;
-  requestId?: string;
-};
-export type StopLoopOptions = {
-  id: string;
-  requestId?: string;
-};
-export type CreateScheduleOptions = {
-  prompt: string;
-  name?: string | null;
-  cadence:
-    | {
-        type: "every";
-        everyMs: number;
-      }
-    | {
-        type: "cron";
-        expression: string;
-      };
-  target:
-    | {
-        type: "self";
-        agentId: string;
-      }
-    | {
-        type: "agent";
-        agentId: string;
-      }
-    | {
-        type: "new-agent";
-        config: {
-          provider: AgentProvider;
-          cwd: string;
-          modeId?: string;
-          model?: string;
-          thinkingOptionId?: string;
-          title?: string | null;
-          approvalPolicy?: string;
-          sandboxMode?: string;
-          networkAccess?: boolean;
-          webSearch?: boolean;
-          extra?: AgentSessionConfig["extra"];
-          systemPrompt?: string;
-          mcpServers?: AgentSessionConfig["mcpServers"];
-        };
-      };
-  maxRuns?: number;
-  expiresAt?: string;
-  requestId?: string;
-};
-export type InspectScheduleOptions = {
-  id: string;
-  requestId?: string;
-};
 type OpenProjectPayload = OpenProjectResponseMessage["payload"];
 type ArchiveWorkspacePayload = ArchiveWorkspaceResponseMessage["payload"];
 
@@ -2857,261 +2677,6 @@ export class DaemonClient {
     });
   }
 
-  async createChatRoom(options: CreateChatRoomOptions): Promise<ChatCreatePayload> {
-    return this.sendCorrelatedSessionRequest({
-      requestId: options.requestId,
-      message: {
-        type: "chat/create",
-        name: options.name,
-        ...(options.purpose ? { purpose: options.purpose } : {}),
-      },
-      responseType: "chat/create/response",
-      timeout: 10000,
-    });
-  }
-
-  async listChatRooms(requestId?: string): Promise<ChatListPayload> {
-    return this.sendCorrelatedSessionRequest({
-      requestId,
-      message: {
-        type: "chat/list",
-      },
-      responseType: "chat/list/response",
-      timeout: 10000,
-    });
-  }
-
-  async inspectChatRoom(options: InspectChatRoomOptions): Promise<ChatInspectPayload> {
-    return this.sendCorrelatedSessionRequest({
-      requestId: options.requestId,
-      message: {
-        type: "chat/inspect",
-        room: options.room,
-      },
-      responseType: "chat/inspect/response",
-      timeout: 10000,
-    });
-  }
-
-  async deleteChatRoom(options: DeleteChatRoomOptions): Promise<ChatDeletePayload> {
-    return this.sendCorrelatedSessionRequest({
-      requestId: options.requestId,
-      message: {
-        type: "chat/delete",
-        room: options.room,
-      },
-      responseType: "chat/delete/response",
-      timeout: 10000,
-    });
-  }
-
-  async postChatMessage(options: PostChatMessageOptions): Promise<ChatPostPayload> {
-    return this.sendCorrelatedSessionRequest({
-      requestId: options.requestId,
-      message: {
-        type: "chat/post",
-        room: options.room,
-        body: options.body,
-        ...(options.authorAgentId ? { authorAgentId: options.authorAgentId } : {}),
-        ...(options.replyToMessageId ? { replyToMessageId: options.replyToMessageId } : {}),
-      },
-      responseType: "chat/post/response",
-      timeout: 10000,
-    });
-  }
-
-  async readChatMessages(options: ReadChatMessagesOptions): Promise<ChatReadPayload> {
-    return this.sendCorrelatedSessionRequest({
-      requestId: options.requestId,
-      message: {
-        type: "chat/read",
-        room: options.room,
-        ...(typeof options.limit === "number" ? { limit: options.limit } : {}),
-        ...(options.since ? { since: options.since } : {}),
-        ...(options.authorAgentId ? { authorAgentId: options.authorAgentId } : {}),
-      },
-      responseType: "chat/read/response",
-      timeout: 10000,
-    });
-  }
-
-  async waitForChatMessages(options: WaitForChatMessagesOptions): Promise<ChatWaitPayload> {
-    return this.sendCorrelatedSessionRequest({
-      requestId: options.requestId,
-      message: {
-        type: "chat/wait",
-        room: options.room,
-        ...(options.afterMessageId ? { afterMessageId: options.afterMessageId } : {}),
-        ...(typeof options.timeoutMs === "number" ? { timeoutMs: options.timeoutMs } : {}),
-      },
-      responseType: "chat/wait/response",
-      timeout: (options.timeoutMs ?? 0) + 10000,
-    });
-  }
-
-  async scheduleCreate(options: CreateScheduleOptions): Promise<ScheduleCreatePayload> {
-    return this.sendCorrelatedSessionRequest({
-      requestId: options.requestId,
-      message: {
-        type: "schedule/create",
-        prompt: options.prompt,
-        cadence: options.cadence,
-        target: options.target,
-        ...(options.name ? { name: options.name } : {}),
-        ...(typeof options.maxRuns === "number" ? { maxRuns: options.maxRuns } : {}),
-        ...(options.expiresAt ? { expiresAt: options.expiresAt } : {}),
-      },
-      responseType: "schedule/create/response",
-      timeout: 10000,
-    });
-  }
-
-  async scheduleList(requestId?: string): Promise<ScheduleListPayload> {
-    return this.sendCorrelatedSessionRequest({
-      requestId,
-      message: {
-        type: "schedule/list",
-      },
-      responseType: "schedule/list/response",
-      timeout: 10000,
-    });
-  }
-
-  async scheduleInspect(options: InspectScheduleOptions): Promise<ScheduleInspectPayload> {
-    return this.sendCorrelatedSessionRequest({
-      requestId: options.requestId,
-      message: {
-        type: "schedule/inspect",
-        scheduleId: options.id,
-      },
-      responseType: "schedule/inspect/response",
-      timeout: 10000,
-    });
-  }
-
-  async scheduleLogs(options: InspectScheduleOptions): Promise<ScheduleLogsPayload> {
-    return this.sendCorrelatedSessionRequest({
-      requestId: options.requestId,
-      message: {
-        type: "schedule/logs",
-        scheduleId: options.id,
-      },
-      responseType: "schedule/logs/response",
-      timeout: 10000,
-    });
-  }
-
-  async schedulePause(options: InspectScheduleOptions): Promise<SchedulePausePayload> {
-    return this.sendCorrelatedSessionRequest({
-      requestId: options.requestId,
-      message: {
-        type: "schedule/pause",
-        scheduleId: options.id,
-      },
-      responseType: "schedule/pause/response",
-      timeout: 10000,
-    });
-  }
-
-  async scheduleResume(options: InspectScheduleOptions): Promise<ScheduleResumePayload> {
-    return this.sendCorrelatedSessionRequest({
-      requestId: options.requestId,
-      message: {
-        type: "schedule/resume",
-        scheduleId: options.id,
-      },
-      responseType: "schedule/resume/response",
-      timeout: 10000,
-    });
-  }
-
-  async scheduleDelete(options: InspectScheduleOptions): Promise<ScheduleDeletePayload> {
-    return this.sendCorrelatedSessionRequest({
-      requestId: options.requestId,
-      message: {
-        type: "schedule/delete",
-        scheduleId: options.id,
-      },
-      responseType: "schedule/delete/response",
-      timeout: 10000,
-    });
-  }
-
-  async loopRun(options: RunLoopOptions): Promise<LoopRunPayload> {
-    return this.sendCorrelatedSessionRequest({
-      requestId: options.requestId,
-      message: {
-        type: "loop/run",
-        prompt: options.prompt,
-        cwd: options.cwd,
-        ...(options.verifyPrompt ? { verifyPrompt: options.verifyPrompt } : {}),
-        ...(options.verifyChecks && options.verifyChecks.length > 0
-          ? { verifyChecks: options.verifyChecks }
-          : {}),
-        ...(options.name ? { name: options.name } : {}),
-        ...(typeof options.sleepMs === "number" ? { sleepMs: options.sleepMs } : {}),
-        ...(typeof options.maxIterations === "number"
-          ? { maxIterations: options.maxIterations }
-          : {}),
-        ...(typeof options.maxTimeMs === "number" ? { maxTimeMs: options.maxTimeMs } : {}),
-      },
-      responseType: "loop/run/response",
-      timeout: 15000,
-    });
-  }
-
-  async loopList(requestId?: string): Promise<LoopListPayload> {
-    return this.sendCorrelatedSessionRequest({
-      requestId,
-      message: {
-        type: "loop/list",
-      },
-      responseType: "loop/list/response",
-      timeout: 10000,
-    });
-  }
-
-  async loopInspect(options: string | InspectLoopOptions): Promise<LoopInspectPayload> {
-    const normalized = typeof options === "string" ? { id: options } : options;
-    return this.sendCorrelatedSessionRequest({
-      requestId: normalized.requestId,
-      message: {
-        type: "loop/inspect",
-        id: normalized.id,
-      },
-      responseType: "loop/inspect/response",
-      timeout: 10000,
-    });
-  }
-
-  async loopLogs(options: string | LoopLogsOptions, afterSeq?: number): Promise<LoopLogsPayload> {
-    const normalized =
-      typeof options === "string" ? { id: options, afterSeq } : options;
-    return this.sendCorrelatedSessionRequest({
-      requestId: normalized.requestId,
-      message: {
-        type: "loop/logs",
-        id: normalized.id,
-        ...(typeof normalized.afterSeq === "number" ? { afterSeq: normalized.afterSeq } : {}),
-      },
-      responseType: "loop/logs/response",
-      timeout: 10000,
-    });
-  }
-
-  async loopStop(options: string | StopLoopOptions): Promise<LoopStopPayload> {
-    const normalized = typeof options === "string" ? { id: options } : options;
-    return this.sendCorrelatedSessionRequest({
-      requestId: normalized.requestId,
-      message: {
-        type: "loop/stop",
-        id: normalized.id,
-      },
-      responseType: "loop/stop/response",
-      timeout: 10000,
-    });
-  }
-
   onTerminalStreamEvent(handler: (event: TerminalStreamEvent) => void): () => void {
     this.terminalStreamListeners.add(handler);
     return () => {

packages/server/src/server/agent-attention-policy.ts

@@ -1,5 +1,3 @@
-import type { AgentAttentionReason } from "../shared/agent-attention-notification.js";
-
 export type ClientAttentionState = {
   deviceType: "web" | "mobile" | null;
   focusedAgentId: string | null;
@@ -7,6 +5,8 @@ export type ClientAttentionState = {
   appVisible: boolean;
 };
 
+export type AgentAttentionReason = "finished" | "error" | "permission";
+
 type ComputeClientNotificationInput = {
   clientState: ClientAttentionState;
   allClientStates: ClientAttentionState[];

packages/server/src/server/agent/agent-manager.ts

@@ -860,39 +860,6 @@ export class AgentManager {
     this.logger.trace({ agentId }, "closeAgent: completed");
   }
 
-  async archiveAgent(agentId: string): Promise<{ archivedAt: string }> {
-    const agent = this.requireAgent(agentId);
-    if (!this.registry) {
-      throw new Error("Agent storage is not configured");
-    }
-
-    await this.registry.applySnapshot(agent, {
-      internal: agent.internal,
-    });
-    const stored = await this.registry.get(agentId);
-    if (!stored) {
-      throw new Error(`Agent ${agentId} not found in storage after snapshot`);
-    }
-
-    const archivedAt = new Date().toISOString();
-    const normalizedStatus =
-      stored.lastStatus === "running" || stored.lastStatus === "initializing"
-        ? "idle"
-        : stored.lastStatus;
-
-    await this.registry.upsert({
-      ...stored,
-      archivedAt,
-      lastStatus: normalizedStatus,
-      requiresAttention: false,
-      attentionReason: null,
-      attentionTimestamp: null,
-    });
-    await this.closeAgent(agentId);
-
-    return { archivedAt };
-  }
-
   async setAgentMode(agentId: string, modeId: string): Promise<void> {
     const agent = this.requireAgent(agentId);
     await agent.session.setMode(modeId);

packages/server/src/server/agent/provider-launch-config.test.ts

@@ -134,40 +134,6 @@ describe("applyProviderEnv", () => {
 });
 
 describe("findExecutable", () => {
-  test("on Windows, resolves executables using current machine and user PATH entries", () => {
-    findExecutableDependencies.platform = vi.fn(() => "win32");
-    process.env.Path = "C:\\Windows\\System32";
-    findExecutableDependencies.execFileSync.mockImplementation(
-      ((command: string, args?: string[]) => {
-        if (command === "powershell") {
-          return "C:\\Windows\\System32\r\nC:\\Users\\boudr\\.local\\bin\r\n";
-        }
-        if (command === "where.exe") {
-          return "C:\\Users\\boudr\\.local\\bin\\claude.exe\r\n";
-        }
-        throw new Error(`unexpected command ${command}`);
-      }) as any,
-    );
-
-    expect(findExecutable("claude", findExecutableDependencies)).toBe(
-      "C:\\Users\\boudr\\.local\\bin\\claude.exe",
-    );
-    const powershellCall = findExecutableDependencies.execFileSync.mock.calls[0];
-    expect(powershellCall?.[0]).toBe("powershell");
-    expect(powershellCall?.[1]).toContain("-NoProfile");
-    expect(powershellCall?.[1]).toContain("-NonInteractive");
-    expect(powershellCall?.[1]).toContain(
-      '$machine = [Environment]::GetEnvironmentVariable("Path", "Machine"); $user = [Environment]::GetEnvironmentVariable("Path", "User"); if ($machine) { Write-Output $machine }; if ($user) { Write-Output $user }',
-    );
-    const whereCall = findExecutableDependencies.execFileSync.mock.calls[1];
-    expect(whereCall?.[0]).toBe("where.exe");
-    expect(whereCall?.[1]).toEqual(["claude"]);
-    expect(whereCall?.[2]?.encoding).toBe("utf8");
-    const env = whereCall?.[2]?.env as Record<string, string | undefined>;
-    expect(env.PATH).toContain("C:\\Users\\boudr\\.local\\bin");
-    expect(env.Path).toContain("C:\\Users\\boudr\\.local\\bin");
-  });
-
   test("uses the last line from login-shell which output", () => {
     findExecutableDependencies.shell = "/bin/zsh";
     findExecutableDependencies.execSync.mockReturnValue(

packages/server/src/server/agent/provider-launch-config.ts

@@ -64,33 +64,6 @@ interface FindExecutableDependencies {
   shell: string | undefined;
 }
 
-function resolveWindowsPathEntries(deps: FindExecutableDependencies): string[] {
-  try {
-    const output = deps.execFileSync(
-      "powershell",
-      [
-        "-NoProfile",
-        "-NonInteractive",
-        "-Command",
-        [
-          '$machine = [Environment]::GetEnvironmentVariable("Path", "Machine")',
-          '$user = [Environment]::GetEnvironmentVariable("Path", "User")',
-          "if ($machine) { Write-Output $machine }",
-          "if ($user) { Write-Output $user }",
-        ].join("; "),
-      ],
-      { encoding: "utf8" },
-    );
-    return output
-      .split(/\r?\n/)
-      .flatMap((line) => line.split(";"))
-      .map((entry) => entry.trim())
-      .filter((entry) => entry.length > 0);
-  } catch {
-    return [];
-  }
-}
-
 function resolveExecutableFromWhichOutput(
   name: string,
   output: string,
@@ -213,21 +186,7 @@ export function findExecutable(
 
   if (deps.platform() === "win32") {
     try {
-      const inheritedPath = process.env["Path"] ?? process.env["PATH"] ?? "";
-      const resolvedPath = [
-        ...inheritedPath.split(";"),
-        ...resolveWindowsPathEntries(deps),
-      ]
-        .map((entry) => entry.trim())
-        .filter((entry) => entry.length > 0)
-        .filter((entry, index, entries) => entries.indexOf(entry) === index)
-        .join(";");
-      const env = {
-        ...process.env,
-        PATH: resolvedPath,
-        Path: resolvedPath,
-      };
-      const out = deps.execFileSync("where.exe", [trimmed], { encoding: "utf8", env }).trim();
+      const out = deps.execSync(`where.exe ${trimmed}`, { encoding: "utf8" }).trim();
       const firstLine = out.split(/\r?\n/)[0]?.trim();
       return firstLine || null;
     } catch {

packages/server/src/server/agent/providers/claude-agent.ts

@@ -258,7 +258,6 @@ type ClaudeOptionsLogSummary = {
   hasCanUseTool: boolean;
   hasSpawnOverride: boolean;
   hasStderrHandler: boolean;
-  pathToClaudeCodeExecutable: string | null;
 };
 
 const MAX_RECENT_STDERR_CHARS = 4000;
@@ -302,10 +301,6 @@ function summarizeClaudeOptionsForLog(options: ClaudeOptions): ClaudeOptionsLogS
     hasCanUseTool: typeof options.canUseTool === "function",
     hasSpawnOverride: typeof options.spawnClaudeCodeProcess === "function",
     hasStderrHandler: typeof options.stderr === "function",
-    pathToClaudeCodeExecutable:
-      typeof options.pathToClaudeCodeExecutable === "string"
-        ? options.pathToClaudeCodeExecutable
-        : null,
   };
 }
 
@@ -1868,22 +1863,6 @@ class ClaudeAgentSession implements AgentSession {
       .join("\n\n");
 
     const claudeBinary = findExecutable("claude");
-    this.logger.debug(
-      {
-        claudeBinary,
-        pathEnvKey:
-          process.env["Path"] !== undefined
-            ? "Path"
-            : process.env["PATH"] !== undefined
-              ? "PATH"
-              : null,
-        pathIncludesClaudeLocalBin:
-          (process.env["Path"] ?? process.env["PATH"] ?? "")
-            .toLowerCase()
-            .includes("\\.local\\bin"),
-      },
-      "Resolved Claude executable",
-    );
     const base: ClaudeOptions = {
       cwd: this.config.cwd,
       includePartialMessages: true,

packages/server/src/server/bootstrap.ts

@@ -99,10 +99,6 @@ import { createAgentMcpServer } from "./agent/mcp-server.js";
 import { createAllClients, shutdownProviders } from "./agent/provider-registry.js";
 import { bootstrapWorkspaceRegistries } from "./workspace-registry-bootstrap.js";
 import { FileBackedProjectRegistry, FileBackedWorkspaceRegistry } from "./workspace-registry.js";
-import { FileBackedChatService } from "./chat/chat-service.js";
-import { CheckoutDiffManager } from "./checkout-diff-manager.js";
-import { LoopService } from "./loop-service.js";
-import { ScheduleService } from "./schedule/service.js";
 import { createTerminalManager, type TerminalManager } from "../terminal/terminal-manager.js";
 import { createConnectionOfferV2, encodeOfferToFragmentUrl } from "./connection-offer.js";
 import { loadOrCreateDaemonKeyPair } from "./daemon-keypair.js";
@@ -377,10 +373,6 @@ export async function createPaseoDaemon(
       path.join(config.paseoHome, "projects", "workspaces.json"),
       logger,
     );
-    const chatService = new FileBackedChatService({
-      paseoHome: config.paseoHome,
-      logger,
-    });
     const agentManager = new AgentManager({
       clients: {
         ...createAllClients(logger, {
@@ -409,28 +401,6 @@ export async function createPaseoDaemon(
       logger,
     });
     logger.info({ elapsed: elapsed() }, "Workspace registries bootstrapped");
-    await chatService.initialize();
-    logger.info({ elapsed: elapsed() }, "Chat service initialized");
-    const checkoutDiffManager = new CheckoutDiffManager({
-      logger,
-      paseoHome: config.paseoHome,
-    });
-    const loopService = new LoopService({
-      paseoHome: config.paseoHome,
-      logger,
-      agentManager,
-    });
-    await loopService.initialize();
-    logger.info({ elapsed: elapsed() }, "Loop service initialized");
-    const scheduleService = new ScheduleService({
-      paseoHome: config.paseoHome,
-      logger,
-      agentManager,
-      agentStorage,
-    });
-    await scheduleService.start();
-    logger.info({ elapsed: elapsed() }, "Schedule service initialized");
-    logger.info({ elapsed: elapsed() }, "Loading persisted agent registry");
     const persistedRecords = await agentStorage.list();
     logger.info(
       { elapsed: elapsed() },
@@ -439,7 +409,6 @@ export async function createPaseoDaemon(
     logger.info(
       "Voice mode configured for agent-scoped resume flow (no dedicated voice assistant provider)",
     );
-    logger.info({ elapsed: elapsed() }, "Preparing voice and MCP runtime");
     let wsServer: VoiceAssistantWebSocketServer | null = null;
     let voiceMcpBridgeManager: VoiceMcpSocketBridgeManager | null = null;
     let unsubscribeSpeechReadiness: (() => void) | null = null;
@@ -664,10 +633,6 @@ export async function createPaseoDaemon(
       },
       projectRegistry,
       workspaceRegistry,
-      chatService,
-      loopService,
-      scheduleService,
-      checkoutDiffManager,
     );
     unsubscribeSpeechReadiness = subscribeSpeechReadiness((snapshot) => {
       wsServer?.publishSpeechReadiness(snapshot);
@@ -761,7 +726,6 @@ export async function createPaseoDaemon(
       unsubscribeSpeechReadiness?.();
       unsubscribeSpeechReadiness = null;
       cleanupSpeechRuntime();
-      await scheduleService.stop().catch(() => undefined);
       await relayTransport?.stop().catch(() => undefined);
       if (wsServer) {
         await wsServer.close();

packages/server/src/server/chat/chat-mentions.test.ts

@@ -1,83 +0,0 @@
-import { describe, expect, test, vi } from "vitest";
-import {
-  buildChatMentionNotification,
-  notifyChatMentions,
-  resolveChatMentionTargetAgentIds,
-} from "./chat-mentions.js";
-
-describe("chat mentions", () => {
-  test("@everyone expands to active non-archived agents", () => {
-    const targets = resolveChatMentionTargetAgentIds({
-      authorAgentId: "author-agent",
-      mentionAgentIds: ["everyone"],
-      storedAgents: [
-        { id: "agent-a", internal: false, archivedAt: null } as any,
-        { id: "agent-b", internal: false, archivedAt: "2026-03-28T00:00:00.000Z" } as any,
-        { id: "author-agent", internal: false, archivedAt: null } as any,
-        { id: "internal-agent", internal: true, archivedAt: null } as any,
-      ],
-      liveAgents: [
-        { id: "agent-c", internal: false } as any,
-        { id: "internal-live", internal: true } as any,
-      ],
-    });
-
-    expect(targets.sort()).toEqual(["agent-a", "agent-c"]);
-  });
-
-  test("@everyone deduplicates with explicit mentions and keeps explicit non-everyone mentions", () => {
-    const targets = resolveChatMentionTargetAgentIds({
-      authorAgentId: "author-agent",
-      mentionAgentIds: ["everyone", "agent-a", "custom-title"],
-      storedAgents: [{ id: "agent-a", internal: false, archivedAt: null } as any],
-      liveAgents: [{ id: "agent-b", internal: false } as any],
-    });
-
-    expect(targets.sort()).toEqual(["agent-a", "agent-b", "custom-title"]);
-  });
-
-  test("notification body strips inline mentions but keeps the room context", () => {
-    expect(
-      buildChatMentionNotification({
-        room: "coord-room",
-        authorAgentId: "author-agent",
-        body: "@agent-a @everyone Check the latest status.",
-        mentionAgentIds: ["agent-a", "everyone"],
-      }),
-    ).toContain("Check the latest status.");
-  });
-
-  test("notifyChatMentions delegates sends for resolved targets", async () => {
-    const resolveAgentIdentifier = vi.fn(async (identifier: string) => ({
-      ok: true as const,
-      agentId: identifier,
-    }));
-    const sendAgentMessage = vi.fn(async () => {});
-    const logger = {
-      warn: vi.fn(),
-    } as any;
-
-    await notifyChatMentions({
-      room: "coord-room",
-      authorAgentId: "author-agent",
-      body: "@everyone Check status",
-      mentionAgentIds: ["everyone"],
-      logger,
-      listStoredAgents: async () => [{ id: "agent-a", internal: false, archivedAt: null } as any],
-      listLiveAgents: () => [{ id: "agent-b", internal: false } as any],
-      resolveAgentIdentifier,
-      sendAgentMessage,
-    });
-
-    expect(resolveAgentIdentifier).toHaveBeenCalledTimes(2);
-    expect(sendAgentMessage).toHaveBeenCalledTimes(2);
-    expect(sendAgentMessage).toHaveBeenCalledWith(
-      "agent-a",
-      expect.stringContaining('room "coord-room"'),
-    );
-    expect(sendAgentMessage).toHaveBeenCalledWith(
-      "agent-b",
-      expect.stringContaining("Check status"),
-    );
-  });
-});

packages/server/src/server/chat/chat-mentions.ts

@@ -1,114 +0,0 @@
-import type pino from "pino";
-import type { StoredAgentRecord } from "../agent/agent-storage.js";
-import type { ManagedAgent } from "../agent/agent-manager.js";
-
-export interface ChatMentionNotificationInput {
-  room: string;
-  authorAgentId: string;
-  body: string;
-  mentionAgentIds: string[];
-}
-
-export interface NotifyChatMentionsInput extends ChatMentionNotificationInput {
-  logger: pino.Logger;
-  listStoredAgents: () => Promise<StoredAgentRecord[]>;
-  listLiveAgents: () => ManagedAgent[];
-  resolveAgentIdentifier: (
-    identifier: string,
-  ) => Promise<{ ok: true; agentId: string } | { ok: false; error: string }>;
-  sendAgentMessage: (agentId: string, text: string) => Promise<void>;
-}
-
-export async function notifyChatMentions(input: NotifyChatMentionsInput): Promise<void> {
-  const mentionAgentIds = await resolveChatMentionTargetAgentIds({
-    authorAgentId: input.authorAgentId,
-    mentionAgentIds: input.mentionAgentIds,
-    storedAgents: await input.listStoredAgents(),
-    liveAgents: input.listLiveAgents(),
-  });
-  if (mentionAgentIds.length === 0) {
-    return;
-  }
-
-  const notification = buildChatMentionNotification({
-    room: input.room,
-    authorAgentId: input.authorAgentId,
-    body: input.body,
-    mentionAgentIds,
-  });
-
-  await Promise.all(
-    mentionAgentIds.map(async (mentionedAgentId) => {
-      const resolved = await input.resolveAgentIdentifier(mentionedAgentId);
-      if (!resolved.ok) {
-        input.logger.warn(
-          { mentionedAgentId, room: input.room, error: resolved.error },
-          "Failed to resolve chat mention target",
-        );
-        return;
-      }
-
-      try {
-        await input.sendAgentMessage(resolved.agentId, notification);
-      } catch (error) {
-        input.logger.warn(
-          { err: error, mentionedAgentId: resolved.agentId, room: input.room },
-          "Failed to notify mentioned agent about chat message",
-        );
-      }
-    }),
-  );
-}
-
-export function resolveChatMentionTargetAgentIds(input: {
-  authorAgentId: string;
-  mentionAgentIds: string[];
-  storedAgents: StoredAgentRecord[];
-  liveAgents: ManagedAgent[];
-}): string[] {
-  const targets = new Set<string>();
-  const mentionsEveryone = input.mentionAgentIds.includes("everyone");
-
-  for (const mentionAgentId of input.mentionAgentIds) {
-    if (mentionAgentId === "everyone") {
-      continue;
-    }
-    if (mentionAgentId !== input.authorAgentId) {
-      targets.add(mentionAgentId);
-    }
-  }
-
-  if (!mentionsEveryone) {
-    return Array.from(targets);
-  }
-
-  for (const record of input.storedAgents) {
-    if (record.internal || record.archivedAt || record.id === input.authorAgentId) {
-      continue;
-    }
-    targets.add(record.id);
-  }
-
-  for (const agent of input.liveAgents) {
-    if (agent.internal || agent.id === input.authorAgentId) {
-      continue;
-    }
-    targets.add(agent.id);
-  }
-
-  return Array.from(targets);
-}
-
-export function buildChatMentionNotification(input: ChatMentionNotificationInput): string {
-  const mentioned = input.mentionAgentIds.map((agentId) => `@${agentId}`).join(", ");
-  const bodyWithoutMentions = input.body.replace(/(^|\s)@[A-Za-z0-9][A-Za-z0-9._-]*/g, "$1").trim();
-  const body = bodyWithoutMentions.length > 0 ? bodyWithoutMentions : input.body;
-
-  return [
-    `Chat mention from ${input.authorAgentId} in room "${input.room}".`,
-    `Mentioned agents: ${mentioned}.`,
-    "Message:",
-    body,
-    `Read the room with: paseo chat read ${input.room} --limit 20`,
-  ].join("\n");
-}

packages/server/src/server/chat/chat-rpc-schemas.ts

@@ -1,116 +0,0 @@
-import { z } from "zod";
-import { ChatMessageSchema, ChatRoomDetailSchema } from "./chat-types.js";
-
-export const ChatCreateRequestSchema = z.object({
-  type: z.literal("chat/create"),
-  requestId: z.string(),
-  name: z.string(),
-  purpose: z.string().optional(),
-});
-
-export const ChatListRequestSchema = z.object({
-  type: z.literal("chat/list"),
-  requestId: z.string(),
-});
-
-export const ChatInspectRequestSchema = z.object({
-  type: z.literal("chat/inspect"),
-  requestId: z.string(),
-  room: z.string(),
-});
-
-export const ChatDeleteRequestSchema = z.object({
-  type: z.literal("chat/delete"),
-  requestId: z.string(),
-  room: z.string(),
-});
-
-export const ChatPostRequestSchema = z.object({
-  type: z.literal("chat/post"),
-  requestId: z.string(),
-  room: z.string(),
-  body: z.string(),
-  authorAgentId: z.string().optional(),
-  replyToMessageId: z.string().optional(),
-});
-
-export const ChatReadRequestSchema = z.object({
-  type: z.literal("chat/read"),
-  requestId: z.string(),
-  room: z.string(),
-  limit: z.number().int().nonnegative().optional(),
-  since: z.string().optional(),
-  authorAgentId: z.string().optional(),
-});
-
-export const ChatWaitRequestSchema = z.object({
-  type: z.literal("chat/wait"),
-  requestId: z.string(),
-  room: z.string(),
-  afterMessageId: z.string().optional(),
-  timeoutMs: z.number().int().nonnegative().optional(),
-});
-
-export const ChatCreateResponseSchema = z.object({
-  type: z.literal("chat/create/response"),
-  payload: z.object({
-    requestId: z.string(),
-    room: ChatRoomDetailSchema.nullable(),
-    error: z.string().nullable(),
-  }),
-});
-
-export const ChatListResponseSchema = z.object({
-  type: z.literal("chat/list/response"),
-  payload: z.object({
-    requestId: z.string(),
-    rooms: z.array(ChatRoomDetailSchema),
-    error: z.string().nullable(),
-  }),
-});
-
-export const ChatInspectResponseSchema = z.object({
-  type: z.literal("chat/inspect/response"),
-  payload: z.object({
-    requestId: z.string(),
-    room: ChatRoomDetailSchema.nullable(),
-    error: z.string().nullable(),
-  }),
-});
-
-export const ChatDeleteResponseSchema = z.object({
-  type: z.literal("chat/delete/response"),
-  payload: z.object({
-    requestId: z.string(),
-    room: ChatRoomDetailSchema.nullable(),
-    error: z.string().nullable(),
-  }),
-});
-
-export const ChatPostResponseSchema = z.object({
-  type: z.literal("chat/post/response"),
-  payload: z.object({
-    requestId: z.string(),
-    message: ChatMessageSchema.nullable(),
-    error: z.string().nullable(),
-  }),
-});
-
-export const ChatReadResponseSchema = z.object({
-  type: z.literal("chat/read/response"),
-  payload: z.object({
-    requestId: z.string(),
-    messages: z.array(ChatMessageSchema),
-    error: z.string().nullable(),
-  }),
-});
-
-export const ChatWaitResponseSchema = z.object({
-  type: z.literal("chat/wait/response"),
-  payload: z.object({
-    requestId: z.string(),
-    messages: z.array(ChatMessageSchema),
-    timedOut: z.boolean(),
-    error: z.string().nullable(),
-  }),
-});

packages/server/src/server/chat/chat-service.test.ts

@@ -1,152 +0,0 @@
-import { afterEach, beforeEach, describe, expect, test } from "vitest";
-import { mkdtemp, readFile, rm } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import path from "node:path";
-import pino from "pino";
-import { ChatServiceError, FileBackedChatService, parseMentionAgentIds } from "./chat-service.js";
-
-describe("FileBackedChatService", () => {
-  let paseoHome: string;
-  let service: FileBackedChatService;
-
-  beforeEach(async () => {
-    paseoHome = await mkdtemp(path.join(tmpdir(), "paseo-chat-service-"));
-    service = new FileBackedChatService({
-      paseoHome,
-      logger: pino({ level: "silent" }),
-    });
-    await service.initialize();
-  });
-
-  afterEach(async () => {
-    await rm(paseoHome, { recursive: true, force: true });
-  });
-
-  test("creates rooms, enforces unique names, and persists to disk", async () => {
-    const created = await service.createRoom({
-      name: "cli-features-epic",
-      purpose: "Coordination room",
-    });
-
-    await expect(
-      service.createRoom({
-        name: "CLI-FEATURES-EPIC",
-      }),
-    ).rejects.toMatchObject<Partial<ChatServiceError>>({
-      code: "chat_room_name_taken",
-    });
-
-    const raw = await readFile(path.join(paseoHome, "chat", "rooms.json"), "utf8");
-    expect(raw).toContain("cli-features-epic");
-    expect(created.name).toBe("cli-features-epic");
-    expect(created.purpose).toBe("Coordination room");
-    expect(created.messageCount).toBe(0);
-  });
-
-  test("resolves rooms by name or ID, validates replies, and reads filtered messages", async () => {
-    const room = await service.createRoom({ name: "auth-refactor" });
-    const first = await service.postMessage({
-      room: room.name,
-      authorAgentId: "agent-a",
-      body: "first message for @agent-b and @agent-c and again @agent-b",
-    });
-    await service.postMessage({
-      room: room.id,
-      authorAgentId: "agent-b",
-      body: "reply",
-      replyToMessageId: first.id,
-    });
-
-    await expect(
-      service.postMessage({
-        room: room.name,
-        authorAgentId: "agent-b",
-        body: "bad reply",
-        replyToMessageId: "missing",
-      }),
-    ).rejects.toMatchObject<Partial<ChatServiceError>>({
-      code: "chat_message_not_found",
-    });
-
-    const all = await service.readMessages({ room: room.name, limit: 10 });
-    expect(all).toHaveLength(2);
-    expect(all[0]?.mentionAgentIds).toEqual(["agent-b", "agent-c"]);
-
-    const byAuthor = await service.readMessages({
-      room: room.id,
-      authorAgentId: "agent-b",
-      limit: 10,
-    });
-    expect(byAuthor).toHaveLength(1);
-    expect(byAuthor[0]?.body).toBe("reply");
-
-    const detail = await service.inspectRoom({ room: room.name });
-    expect(detail.room.messageCount).toBe(2);
-    expect(detail.room.lastMessageAt).toBeTruthy();
-  });
-
-  test("waits for new messages after a cursor and times out with an empty result", async () => {
-    const room = await service.createRoom({ name: "loop-status" });
-    const first = await service.postMessage({
-      room: room.name,
-      authorAgentId: "agent-a",
-      body: "ready",
-    });
-
-    const waitPromise = service.waitForMessages({
-      room: room.name,
-      afterMessageId: first.id,
-      timeoutMs: 1000,
-    });
-    await service.postMessage({
-      room: room.name,
-      authorAgentId: "agent-b",
-      body: "new work",
-    });
-
-    const waited = await waitPromise;
-    expect(waited).toHaveLength(1);
-    expect(waited[0]?.body).toBe("new work");
-
-    const timedOut = await service.waitForMessages({
-      room: room.name,
-      afterMessageId: waited[0]?.id,
-      timeoutMs: 10,
-    });
-    expect(timedOut).toEqual([]);
-  });
-
-  test("deletes rooms, removes messages, and rejects pending waiters", async () => {
-    const room = await service.createRoom({ name: "schedule-jobs" });
-    await service.postMessage({
-      room: room.name,
-      authorAgentId: "agent-a",
-      body: "hello",
-    });
-
-    const waitPromise = service.waitForMessages({
-      room: room.name,
-      timeoutMs: 1000,
-    });
-    const deleted = await service.deleteRoom({ room: room.id });
-    expect(deleted.room.messageCount).toBe(1);
-
-    await expect(waitPromise).rejects.toMatchObject<Partial<ChatServiceError>>({
-      code: "chat_room_deleted",
-    });
-    await expect(service.inspectRoom({ room: room.name })).rejects.toMatchObject<
-      Partial<ChatServiceError>
-    >({
-      code: "chat_room_not_found",
-    });
-  });
-
-  test("extracts inline mentions from chat bodies", () => {
-    expect(
-      parseMentionAgentIds(
-        "Checking with @agent-a, (@agent_b), @everyone, and duplicate @agent-a again.",
-      ),
-    ).toEqual(["agent-a", "agent_b", "everyone"]);
-    expect(parseMentionAgentIds("email@example.com is not a mention")).toEqual([]);
-  });
-});

packages/server/src/server/chat/chat-service.ts

@@ -1,449 +0,0 @@
-import { randomUUID } from "node:crypto";
-import { promises as fs } from "node:fs";
-import path from "node:path";
-import type pino from "pino";
-import { z } from "zod";
-import {
-  ChatMessageSchema,
-  ChatRoomDetailSchema,
-  ChatRoomSchema,
-  type ChatMessage,
-  type ChatRoom,
-  type ChatRoomDetail,
-} from "./chat-types.js";
-
-const ChatStorePayloadSchema = z.object({
-  rooms: z.array(ChatRoomSchema),
-  messages: z.array(ChatMessageSchema),
-});
-
-type ChatStorePayload = z.infer<typeof ChatStorePayloadSchema>;
-
-function normalizeRoomName(name: string): string {
-  return name.trim().toLocaleLowerCase();
-}
-
-function trimToNull(value: string | null | undefined): string | null {
-  if (typeof value !== "string") {
-    return null;
-  }
-  const trimmed = value.trim();
-  return trimmed.length > 0 ? trimmed : null;
-}
-
-const CHAT_MENTION_PATTERN = /(?:^|[\s(])@([A-Za-z0-9][A-Za-z0-9._-]*)/g;
-
-export function parseMentionAgentIds(body: string): string[] {
-  const mentionAgentIds = new Set<string>();
-  for (const match of body.matchAll(CHAT_MENTION_PATTERN)) {
-    const agentId = match[1]?.trim();
-    if (agentId) {
-      mentionAgentIds.add(agentId);
-    }
-  }
-  return Array.from(mentionAgentIds).sort();
-}
-
-export class ChatServiceError extends Error {
-  readonly code: string;
-
-  constructor(code: string, message: string) {
-    super(message);
-    this.name = "ChatServiceError";
-    this.code = code;
-  }
-}
-
-type Waiter = {
-  roomId: string;
-  afterMessageId: string | null;
-  resolve: (messages: ChatMessage[]) => void;
-  reject: (error: Error) => void;
-  timeout: ReturnType<typeof setTimeout> | null;
-};
-
-export interface CreateChatRoomInput {
-  name: string;
-  purpose?: string | null;
-}
-
-export interface InspectChatRoomInput {
-  room: string;
-}
-
-export interface DeleteChatRoomInput {
-  room: string;
-}
-
-export interface PostChatMessageInput {
-  room: string;
-  authorAgentId: string;
-  body: string;
-  replyToMessageId?: string | null;
-}
-
-export interface ReadChatMessagesInput {
-  room: string;
-  limit?: number;
-  since?: string;
-  authorAgentId?: string;
-}
-
-export interface WaitForChatMessagesInput {
-  room: string;
-  afterMessageId?: string | null;
-  timeoutMs?: number;
-}
-
-export interface DeleteChatRoomResult {
-  room: ChatRoomDetail;
-}
-
-export interface InspectChatRoomResult {
-  room: ChatRoomDetail;
-}
-
-export class FileBackedChatService {
-  private readonly filePath: string;
-  private readonly logger: pino.Logger;
-  private loaded = false;
-  private readonly rooms = new Map<string, ChatRoom>();
-  private readonly messagesByRoomId = new Map<string, ChatMessage[]>();
-  private persistQueue: Promise<void> = Promise.resolve();
-  private readonly waitersByRoomId = new Map<string, Set<Waiter>>();
-
-  constructor(options: { paseoHome: string; logger: pino.Logger }) {
-    this.filePath = path.join(options.paseoHome, "chat", "rooms.json");
-    this.logger = options.logger.child({ component: "chat-service" });
-  }
-
-  async initialize(): Promise<void> {
-    await this.load();
-  }
-
-  async createRoom(input: CreateChatRoomInput): Promise<ChatRoomDetail> {
-    await this.load();
-    const name = input.name.trim();
-    if (name.length === 0) {
-      throw new ChatServiceError("invalid_chat_room_name", "Chat room name is required");
-    }
-    if (this.findRoomByName(name)) {
-      throw new ChatServiceError(
-        "chat_room_name_taken",
-        `Chat room already exists with name: ${name}`,
-      );
-    }
-
-    const now = new Date().toISOString();
-    const room = ChatRoomSchema.parse({
-      id: randomUUID(),
-      name,
-      purpose: trimToNull(input.purpose),
-      createdAt: now,
-      updatedAt: now,
-    });
-    this.rooms.set(room.id, room);
-    await this.enqueuePersist();
-    return this.toRoomDetail(room);
-  }
-
-  async listRooms(): Promise<ChatRoomDetail[]> {
-    await this.load();
-    return Array.from(this.rooms.values())
-      .map((room) => this.toRoomDetail(room))
-      .sort((left, right) => right.updatedAt.localeCompare(left.updatedAt));
-  }
-
-  async inspectRoom(input: InspectChatRoomInput): Promise<InspectChatRoomResult> {
-    await this.load();
-    const room = this.resolveRoom(input.room);
-    return {
-      room: this.toRoomDetail(room),
-    };
-  }
-
-  async deleteRoom(input: DeleteChatRoomInput): Promise<DeleteChatRoomResult> {
-    await this.load();
-    const room = this.resolveRoom(input.room);
-    const detail = this.toRoomDetail(room);
-    this.rooms.delete(room.id);
-    this.messagesByRoomId.delete(room.id);
-    await this.enqueuePersist();
-    this.rejectWaiters(
-      room.id,
-      new ChatServiceError("chat_room_deleted", `Chat room deleted: ${room.name}`),
-    );
-    return { room: detail };
-  }
-
-  async postMessage(input: PostChatMessageInput): Promise<ChatMessage> {
-    await this.load();
-    const room = this.resolveRoom(input.room);
-    const body = input.body.trim();
-    if (body.length === 0) {
-      throw new ChatServiceError("invalid_chat_message", "Chat message body is required");
-    }
-    const authorAgentId = input.authorAgentId.trim();
-    if (authorAgentId.length === 0) {
-      throw new ChatServiceError("invalid_chat_author", "Chat message author is required");
-    }
-
-    const messages = this.getRoomMessages(room.id);
-    const replyToMessageId = trimToNull(input.replyToMessageId);
-    if (replyToMessageId) {
-      const replyTarget = messages.find((message) => message.id === replyToMessageId);
-      if (!replyTarget) {
-        throw new ChatServiceError(
-          "chat_message_not_found",
-          `Reply target not found: ${replyToMessageId}`,
-        );
-      }
-    }
-
-    const createdAt = new Date().toISOString();
-    const message = ChatMessageSchema.parse({
-      id: randomUUID(),
-      roomId: room.id,
-      authorAgentId,
-      body,
-      replyToMessageId,
-      mentionAgentIds: parseMentionAgentIds(body),
-      createdAt,
-    });
-
-    messages.push(message);
-    this.messagesByRoomId.set(room.id, messages);
-    this.rooms.set(
-      room.id,
-      ChatRoomSchema.parse({
-        ...room,
-        updatedAt: createdAt,
-      }),
-    );
-    await this.enqueuePersist();
-    this.notifyWaiters(room.id);
-    return message;
-  }
-
-  async readMessages(input: ReadChatMessagesInput): Promise<ChatMessage[]> {
-    await this.load();
-    const room = this.resolveRoom(input.room);
-    const messages = [...this.getRoomMessages(room.id)];
-    const since = trimToNull(input.since);
-    const authorAgentId = trimToNull(input.authorAgentId);
-    const limit = this.normalizeLimit(input.limit);
-
-    const filtered = messages.filter((message) => {
-      if (since && message.createdAt < since) {
-        return false;
-      }
-      if (authorAgentId && message.authorAgentId !== authorAgentId) {
-        return false;
-      }
-      return true;
-    });
-
-    if (limit === 0 || filtered.length <= limit) {
-      return filtered;
-    }
-    return filtered.slice(filtered.length - limit);
-  }
-
-  async waitForMessages(input: WaitForChatMessagesInput): Promise<ChatMessage[]> {
-    await this.load();
-    const room = this.resolveRoom(input.room);
-    const timeoutMs = Math.max(0, Math.floor(input.timeoutMs ?? 0));
-    const afterMessageId = trimToNull(input.afterMessageId);
-
-    if (afterMessageId) {
-      const existing = this.selectMessagesAfter(room.id, afterMessageId);
-      if (existing.length > 0) {
-        return existing;
-      }
-      const knownMessage = this.getRoomMessages(room.id).some((message) => message.id === afterMessageId);
-      if (!knownMessage) {
-        throw new ChatServiceError(
-          "chat_message_not_found",
-          `Wait cursor not found: ${afterMessageId}`,
-        );
-      }
-    }
-
-    return new Promise<ChatMessage[]>((resolve, reject) => {
-      const waiter: Waiter = {
-        roomId: room.id,
-        afterMessageId,
-        resolve: (messages) => {
-          if (waiter.timeout) {
-            clearTimeout(waiter.timeout);
-            waiter.timeout = null;
-          }
-          this.removeWaiter(waiter);
-          resolve(messages);
-        },
-        reject: (error) => {
-          if (waiter.timeout) {
-            clearTimeout(waiter.timeout);
-            waiter.timeout = null;
-          }
-          this.removeWaiter(waiter);
-          reject(error);
-        },
-        timeout: null,
-      };
-
-      if (timeoutMs > 0) {
-        waiter.timeout = setTimeout(() => {
-          waiter.resolve([]);
-        }, timeoutMs);
-      }
-
-      const roomWaiters = this.waitersByRoomId.get(room.id) ?? new Set<Waiter>();
-      roomWaiters.add(waiter);
-      this.waitersByRoomId.set(room.id, roomWaiters);
-    });
-  }
-
-  private async load(): Promise<void> {
-    if (this.loaded) {
-      return;
-    }
-
-    this.rooms.clear();
-    this.messagesByRoomId.clear();
-
-    try {
-      const raw = await fs.readFile(this.filePath, "utf8");
-      const parsed = ChatStorePayloadSchema.parse(JSON.parse(raw));
-      for (const room of parsed.rooms) {
-        this.rooms.set(room.id, room);
-      }
-      for (const message of parsed.messages) {
-        const messages = this.messagesByRoomId.get(message.roomId) ?? [];
-        messages.push(message);
-        this.messagesByRoomId.set(message.roomId, messages);
-      }
-    } catch (error) {
-      const code = (error as NodeJS.ErrnoException).code;
-      if (code !== "ENOENT") {
-        this.logger.error({ err: error, filePath: this.filePath }, "Failed to load chat store");
-      }
-    }
-
-    this.loaded = true;
-  }
-
-  private async enqueuePersist(): Promise<void> {
-    const nextPersist = this.persistQueue.then(() => this.persist());
-    this.persistQueue = nextPersist.catch(() => {});
-    await nextPersist;
-  }
-
-  private async persist(): Promise<void> {
-    const payload: ChatStorePayload = {
-      rooms: Array.from(this.rooms.values()).sort((left, right) => left.createdAt.localeCompare(right.createdAt)),
-      messages: Array.from(this.messagesByRoomId.values())
-        .flat()
-        .sort((left, right) => left.createdAt.localeCompare(right.createdAt)),
-    };
-    await fs.mkdir(path.dirname(this.filePath), { recursive: true });
-    const tempPath = `${this.filePath}.${process.pid}.${Date.now()}.${randomUUID()}.tmp`;
-    await fs.writeFile(tempPath, JSON.stringify(payload, null, 2), "utf8");
-    await fs.rename(tempPath, this.filePath);
-  }
-
-  private findRoomByName(name: string): ChatRoom | null {
-    const normalizedName = normalizeRoomName(name);
-    for (const room of this.rooms.values()) {
-      if (normalizeRoomName(room.name) === normalizedName) {
-        return room;
-      }
-    }
-    return null;
-  }
-
-  private resolveRoom(roomSelector: string): ChatRoom {
-    const selector = roomSelector.trim();
-    if (selector.length === 0) {
-      throw new ChatServiceError("invalid_chat_room", "Chat room name or ID is required");
-    }
-    const byId = this.rooms.get(selector);
-    if (byId) {
-      return byId;
-    }
-    const byName = this.findRoomByName(selector);
-    if (byName) {
-      return byName;
-    }
-    throw new ChatServiceError("chat_room_not_found", `Chat room not found: ${selector}`);
-  }
-
-  private getRoomMessages(roomId: string): ChatMessage[] {
-    return this.messagesByRoomId.get(roomId) ?? [];
-  }
-
-  private toRoomDetail(room: ChatRoom): ChatRoomDetail {
-    const messages = this.getRoomMessages(room.id);
-    return ChatRoomDetailSchema.parse({
-      ...room,
-      messageCount: messages.length,
-      lastMessageAt: messages[messages.length - 1]?.createdAt ?? null,
-    });
-  }
-
-  private normalizeLimit(limit: number | undefined): number {
-    if (limit === undefined) {
-      return 20;
-    }
-    const normalized = Math.max(0, Math.floor(limit));
-    return normalized;
-  }
-
-  private selectMessagesAfter(roomId: string, afterMessageId: string): ChatMessage[] {
-    const messages = this.getRoomMessages(roomId);
-    const index = messages.findIndex((message) => message.id === afterMessageId);
-    if (index === -1) {
-      return [];
-    }
-    return messages.slice(index + 1);
-  }
-
-  private notifyWaiters(roomId: string): void {
-    const waiters = this.waitersByRoomId.get(roomId);
-    if (!waiters || waiters.size === 0) {
-      return;
-    }
-
-    for (const waiter of [...waiters]) {
-      const messages =
-        waiter.afterMessageId === null
-          ? this.getRoomMessages(roomId).slice(-1)
-          : this.selectMessagesAfter(roomId, waiter.afterMessageId);
-      if (messages.length === 0) {
-        continue;
-      }
-      waiter.resolve(messages);
-    }
-  }
-
-  private removeWaiter(waiter: Waiter): void {
-    const waiters = this.waitersByRoomId.get(waiter.roomId);
-    if (!waiters) {
-      return;
-    }
-    waiters.delete(waiter);
-    if (waiters.size === 0) {
-      this.waitersByRoomId.delete(waiter.roomId);
-    }
-  }
-
-  private rejectWaiters(roomId: string, error: Error): void {
-    const waiters = this.waitersByRoomId.get(roomId);
-    if (!waiters) {
-      return;
-    }
-    for (const waiter of [...waiters]) {
-      waiter.reject(error);
-    }
-  }
-}

packages/server/src/server/chat/chat-types.ts

@@ -1,30 +0,0 @@
-import { z } from "zod";
-
-export const ChatRoomSchema = z.object({
-  id: z.string(),
-  name: z.string(),
-  purpose: z.string().nullable(),
-  createdAt: z.string(),
-  updatedAt: z.string(),
-});
-
-export type ChatRoom = z.infer<typeof ChatRoomSchema>;
-
-export const ChatMessageSchema = z.object({
-  id: z.string(),
-  roomId: z.string(),
-  authorAgentId: z.string(),
-  body: z.string(),
-  replyToMessageId: z.string().nullable(),
-  mentionAgentIds: z.array(z.string()),
-  createdAt: z.string(),
-});
-
-export type ChatMessage = z.infer<typeof ChatMessageSchema>;
-
-export const ChatRoomDetailSchema = ChatRoomSchema.extend({
-  messageCount: z.number().int().nonnegative(),
-  lastMessageAt: z.string().nullable(),
-});
-
-export type ChatRoomDetail = z.infer<typeof ChatRoomDetailSchema>;

packages/server/src/server/checkout-diff-manager.ts

@@ -1,361 +0,0 @@
-import { watch, type FSWatcher } from "node:fs";
-import { exec } from "child_process";
-import { promisify } from "util";
-import type pino from "pino";
-import type { SubscribeCheckoutDiffRequest, SessionOutboundMessage } from "./messages.js";
-import { getCheckoutDiff } from "../utils/checkout-git.js";
-import { expandTilde } from "../utils/path.js";
-import { READ_ONLY_GIT_ENV, resolveCheckoutGitDir, toCheckoutError } from "./checkout-git-utils.js";
-
-const execAsync = promisify(exec);
-
-const CHECKOUT_DIFF_WATCH_DEBOUNCE_MS = 150;
-const CHECKOUT_DIFF_FALLBACK_REFRESH_MS = 5_000;
-
-export type CheckoutDiffCompareInput = SubscribeCheckoutDiffRequest["compare"];
-
-export type CheckoutDiffSnapshotPayload = Omit<
-  Extract<SessionOutboundMessage, { type: "checkout_diff_update" }>["payload"],
-  "subscriptionId"
->;
-
-export type CheckoutDiffMetrics = {
-  checkoutDiffTargetCount: number;
-  checkoutDiffSubscriptionCount: number;
-  checkoutDiffWatcherCount: number;
-  checkoutDiffFallbackRefreshTargetCount: number;
-};
-
-type CheckoutDiffWatchTarget = {
-  key: string;
-  cwd: string;
-  diffCwd: string;
-  compare: CheckoutDiffCompareInput;
-  listeners: Set<(snapshot: CheckoutDiffSnapshotPayload) => void>;
-  watchers: FSWatcher[];
-  fallbackRefreshInterval: NodeJS.Timeout | null;
-  debounceTimer: NodeJS.Timeout | null;
-  refreshPromise: Promise<void> | null;
-  refreshQueued: boolean;
-  latestPayload: CheckoutDiffSnapshotPayload | null;
-  latestFingerprint: string | null;
-};
-
-export class CheckoutDiffManager {
-  private readonly logger: pino.Logger;
-  private readonly paseoHome: string;
-  private readonly targets = new Map<string, CheckoutDiffWatchTarget>();
-
-  constructor(options: { logger: pino.Logger; paseoHome: string }) {
-    this.logger = options.logger.child({ module: "checkout-diff-manager" });
-    this.paseoHome = options.paseoHome;
-  }
-
-  async subscribe(
-    params: {
-      cwd: string;
-      compare: CheckoutDiffCompareInput;
-    },
-    listener: (snapshot: CheckoutDiffSnapshotPayload) => void,
-  ): Promise<{ initial: CheckoutDiffSnapshotPayload; unsubscribe: () => void }> {
-    const cwd = params.cwd;
-    const compare = this.normalizeCompare(params.compare);
-    const target = await this.ensureTarget(cwd, compare);
-    target.listeners.add(listener);
-
-    const initial =
-      target.latestPayload ??
-      (await this.computeCheckoutDiffSnapshot(target.cwd, target.compare, {
-        diffCwd: target.diffCwd,
-      }));
-    target.latestPayload = initial;
-    target.latestFingerprint = JSON.stringify(initial);
-    return {
-      initial,
-      unsubscribe: () => {
-        this.removeListener(target.key, listener);
-      },
-    };
-  }
-
-  scheduleRefreshForCwd(cwd: string): void {
-    const resolvedCwd = expandTilde(cwd);
-    for (const target of this.targets.values()) {
-      if (target.cwd !== resolvedCwd && target.diffCwd !== resolvedCwd) {
-        continue;
-      }
-      this.scheduleTargetRefresh(target);
-    }
-  }
-
-  getMetrics(): CheckoutDiffMetrics {
-    let checkoutDiffSubscriptionCount = 0;
-    let checkoutDiffWatcherCount = 0;
-    let checkoutDiffFallbackRefreshTargetCount = 0;
-
-    for (const target of this.targets.values()) {
-      checkoutDiffSubscriptionCount += target.listeners.size;
-      checkoutDiffWatcherCount += target.watchers.length;
-      if (target.fallbackRefreshInterval) {
-        checkoutDiffFallbackRefreshTargetCount += 1;
-      }
-    }
-
-    return {
-      checkoutDiffTargetCount: this.targets.size,
-      checkoutDiffSubscriptionCount,
-      checkoutDiffWatcherCount,
-      checkoutDiffFallbackRefreshTargetCount,
-    };
-  }
-
-  dispose(): void {
-    for (const target of this.targets.values()) {
-      this.closeTarget(target);
-    }
-    this.targets.clear();
-  }
-
-  private normalizeCompare(compare: CheckoutDiffCompareInput): CheckoutDiffCompareInput {
-    if (compare.mode === "uncommitted") {
-      return { mode: "uncommitted" };
-    }
-    const trimmedBaseRef = compare.baseRef?.trim();
-    return trimmedBaseRef ? { mode: "base", baseRef: trimmedBaseRef } : { mode: "base" };
-  }
-
-  private buildTargetKey(cwd: string, compare: CheckoutDiffCompareInput): string {
-    return JSON.stringify([
-      cwd,
-      compare.mode,
-      compare.mode === "base" ? (compare.baseRef ?? "") : "",
-    ]);
-  }
-
-  private closeTarget(target: CheckoutDiffWatchTarget): void {
-    if (target.debounceTimer) {
-      clearTimeout(target.debounceTimer);
-      target.debounceTimer = null;
-    }
-    if (target.fallbackRefreshInterval) {
-      clearInterval(target.fallbackRefreshInterval);
-      target.fallbackRefreshInterval = null;
-    }
-    for (const watcher of target.watchers) {
-      watcher.close();
-    }
-    target.watchers = [];
-    target.listeners.clear();
-  }
-
-  private removeListener(
-    targetKey: string,
-    listener: (snapshot: CheckoutDiffSnapshotPayload) => void,
-  ): void {
-    const target = this.targets.get(targetKey);
-    if (!target) {
-      return;
-    }
-    target.listeners.delete(listener);
-    if (target.listeners.size > 0) {
-      return;
-    }
-    this.closeTarget(target);
-    this.targets.delete(targetKey);
-  }
-
-  private async resolveCheckoutWatchRoot(cwd: string): Promise<string | null> {
-    try {
-      const { stdout } = await execAsync("git rev-parse --path-format=absolute --show-toplevel", {
-        cwd,
-        env: READ_ONLY_GIT_ENV,
-      });
-      const root = stdout.trim();
-      return root.length > 0 ? root : null;
-    } catch {
-      return null;
-    }
-  }
-
-  private scheduleTargetRefresh(target: CheckoutDiffWatchTarget): void {
-    if (target.debounceTimer) {
-      clearTimeout(target.debounceTimer);
-    }
-    target.debounceTimer = setTimeout(() => {
-      target.debounceTimer = null;
-      void this.refreshTarget(target);
-    }, CHECKOUT_DIFF_WATCH_DEBOUNCE_MS);
-  }
-
-  private async computeCheckoutDiffSnapshot(
-    cwd: string,
-    compare: CheckoutDiffCompareInput,
-    options?: { diffCwd?: string },
-  ): Promise<CheckoutDiffSnapshotPayload> {
-    const diffCwd = options?.diffCwd ?? cwd;
-    try {
-      const diffResult = await getCheckoutDiff(
-        diffCwd,
-        {
-          mode: compare.mode,
-          baseRef: compare.baseRef,
-          includeStructured: true,
-        },
-        { paseoHome: this.paseoHome },
-      );
-      const files = [...(diffResult.structured ?? [])];
-      files.sort((a, b) => {
-        if (a.path === b.path) return 0;
-        return a.path < b.path ? -1 : 1;
-      });
-      return {
-        cwd,
-        files,
-        error: null,
-      };
-    } catch (error) {
-      return {
-        cwd,
-        files: [],
-        error: toCheckoutError(error),
-      };
-    }
-  }
-
-  private async refreshTarget(target: CheckoutDiffWatchTarget): Promise<void> {
-    if (target.refreshPromise) {
-      target.refreshQueued = true;
-      return;
-    }
-
-    target.refreshPromise = (async () => {
-      do {
-        target.refreshQueued = false;
-        const snapshot = await this.computeCheckoutDiffSnapshot(target.cwd, target.compare, {
-          diffCwd: target.diffCwd,
-        });
-        target.latestPayload = snapshot;
-        const fingerprint = JSON.stringify(snapshot);
-        if (fingerprint !== target.latestFingerprint) {
-          target.latestFingerprint = fingerprint;
-          for (const listener of target.listeners) {
-            listener(snapshot);
-          }
-        }
-      } while (target.refreshQueued);
-    })();
-
-    try {
-      await target.refreshPromise;
-    } finally {
-      target.refreshPromise = null;
-    }
-  }
-
-  private async ensureTarget(
-    cwd: string,
-    compare: CheckoutDiffCompareInput,
-  ): Promise<CheckoutDiffWatchTarget> {
-    const targetKey = this.buildTargetKey(cwd, compare);
-    const existing = this.targets.get(targetKey);
-    if (existing) {
-      return existing;
-    }
-
-    const watchRoot = await this.resolveCheckoutWatchRoot(cwd);
-    const target: CheckoutDiffWatchTarget = {
-      key: targetKey,
-      cwd,
-      diffCwd: watchRoot ?? cwd,
-      compare,
-      listeners: new Set(),
-      watchers: [],
-      fallbackRefreshInterval: null,
-      debounceTimer: null,
-      refreshPromise: null,
-      refreshQueued: false,
-      latestPayload: null,
-      latestFingerprint: null,
-    };
-
-    const repoWatchPath = watchRoot ?? cwd;
-    const watchPaths = new Set<string>([repoWatchPath]);
-    const gitDir = await resolveCheckoutGitDir(cwd);
-    if (gitDir) {
-      watchPaths.add(gitDir);
-    }
-
-    let hasRecursiveRepoCoverage = false;
-    const allowRecursiveRepoWatch = process.platform !== "linux";
-    for (const watchPath of watchPaths) {
-      const shouldTryRecursive = watchPath === repoWatchPath && allowRecursiveRepoWatch;
-      const createWatcher = (recursive: boolean): FSWatcher =>
-        watch(watchPath, { recursive }, () => {
-          this.scheduleTargetRefresh(target);
-        });
-
-      let watcher: FSWatcher | null = null;
-      let watcherIsRecursive = false;
-      try {
-        if (shouldTryRecursive) {
-          watcher = createWatcher(true);
-          watcherIsRecursive = true;
-        } else {
-          watcher = createWatcher(false);
-        }
-      } catch (error) {
-        if (shouldTryRecursive) {
-          try {
-            watcher = createWatcher(false);
-            this.logger.warn(
-              { err: error, watchPath, cwd, compare },
-              "Checkout diff recursive watch unavailable; using non-recursive fallback",
-            );
-          } catch (fallbackError) {
-            this.logger.warn(
-              { err: fallbackError, watchPath, cwd, compare },
-              "Failed to start checkout diff watcher",
-            );
-          }
-        } else {
-          this.logger.warn(
-            { err: error, watchPath, cwd, compare },
-            "Failed to start checkout diff watcher",
-          );
-        }
-      }
-
-      if (!watcher) {
-        continue;
-      }
-
-      watcher.on("error", (error) => {
-        this.logger.warn({ err: error, watchPath, cwd, compare }, "Checkout diff watcher error");
-      });
-      target.watchers.push(watcher);
-      if (watchPath === repoWatchPath && watcherIsRecursive) {
-        hasRecursiveRepoCoverage = true;
-      }
-    }
-
-    const missingRepoCoverage = !hasRecursiveRepoCoverage;
-    if (target.watchers.length === 0 || missingRepoCoverage) {
-      target.fallbackRefreshInterval = setInterval(() => {
-        this.scheduleTargetRefresh(target);
-      }, CHECKOUT_DIFF_FALLBACK_REFRESH_MS);
-      this.logger.warn(
-        {
-          cwd,
-          compare,
-          intervalMs: CHECKOUT_DIFF_FALLBACK_REFRESH_MS,
-          reason:
-            target.watchers.length === 0 ? "no_watchers" : "missing_recursive_repo_root_coverage",
-        },
-        "Checkout diff watchers unavailable; using timed refresh fallback",
-      );
-    }
-
-    this.targets.set(targetKey, target);
-    return target;
-  }
-}

packages/server/src/server/checkout-git-utils.ts

@@ -1,50 +0,0 @@
-import { exec } from "child_process";
-import { promisify } from "util";
-import {
-  MergeConflictError,
-  MergeFromBaseConflictError,
-  NotGitRepoError,
-} from "../utils/checkout-git.js";
-
-const execAsync = promisify(exec);
-
-export const READ_ONLY_GIT_ENV: NodeJS.ProcessEnv = {
-  ...process.env,
-  GIT_OPTIONAL_LOCKS: "0",
-};
-
-export type CheckoutErrorCode = "NOT_GIT_REPO" | "NOT_ALLOWED" | "MERGE_CONFLICT" | "UNKNOWN";
-
-export type CheckoutErrorPayload = {
-  code: CheckoutErrorCode;
-  message: string;
-};
-
-export async function resolveCheckoutGitDir(cwd: string): Promise<string | null> {
-  try {
-    const { stdout } = await execAsync("git rev-parse --absolute-git-dir", {
-      cwd,
-      env: READ_ONLY_GIT_ENV,
-    });
-    const gitDir = stdout.trim();
-    return gitDir.length > 0 ? gitDir : null;
-  } catch {
-    return null;
-  }
-}
-
-export function toCheckoutError(error: unknown): CheckoutErrorPayload {
-  if (error instanceof NotGitRepoError) {
-    return { code: "NOT_GIT_REPO", message: error.message };
-  }
-  if (error instanceof MergeConflictError) {
-    return { code: "MERGE_CONFLICT", message: error.message };
-  }
-  if (error instanceof MergeFromBaseConflictError) {
-    return { code: "MERGE_CONFLICT", message: error.message };
-  }
-  if (error instanceof Error) {
-    return { code: "UNKNOWN", message: error.message };
-  }
-  return { code: "UNKNOWN", message: String(error) };
-}

packages/server/src/server/loop-service.test.ts

@@ -1,480 +0,0 @@
-import os from "node:os";
-import path from "node:path";
-import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
-import { randomUUID } from "node:crypto";
-import { beforeEach, afterEach, describe, expect, test } from "vitest";
-import type {
-  AgentCapabilityFlags,
-  AgentClient,
-  AgentLaunchContext,
-  AgentMode,
-  AgentModelDefinition,
-  AgentPersistenceHandle,
-  AgentPromptInput,
-  AgentRunOptions,
-  AgentRunResult,
-  AgentSession,
-  AgentSessionConfig,
-  AgentStreamEvent,
-  AgentSlashCommand,
-  AgentRuntimeInfo,
-  ListModelsOptions,
-  AgentProvider,
-} from "./agent/agent-sdk-types.js";
-import { AgentStorage } from "./agent/agent-storage.js";
-import { AgentManager } from "./agent/agent-manager.js";
-import { LoopService } from "./loop-service.js";
-import { createTestLogger } from "../test-utils/test-logger.js";
-
-const TEST_CAPABILITIES: AgentCapabilityFlags = {
-  supportsStreaming: true,
-  supportsSessionPersistence: true,
-  supportsDynamicModes: false,
-  supportsMcpServers: false,
-  supportsReasoningStream: false,
-  supportsToolInvocations: false,
-};
-
-interface ScriptedAgentBehavior {
-  onRun(input: { config: AgentSessionConfig; prompt: string; turnId: string }): Promise<string>;
-}
-
-class ScriptedAgentClient implements AgentClient {
-  readonly provider: AgentProvider;
-  readonly capabilities = TEST_CAPABILITIES;
-
-  constructor(
-    provider: AgentProvider,
-    private readonly behavior: ScriptedAgentBehavior,
-  ) {
-    this.provider = provider;
-  }
-
-  async isAvailable(): Promise<boolean> {
-    return true;
-  }
-
-  async createSession(
-    config: AgentSessionConfig,
-    _launchContext?: AgentLaunchContext,
-  ): Promise<AgentSession> {
-    return new ScriptedAgentSession(config, this.provider, this.behavior);
-  }
-
-  async resumeSession(
-    _handle: AgentPersistenceHandle,
-    overrides?: Partial<AgentSessionConfig>,
-  ): Promise<AgentSession> {
-    return new ScriptedAgentSession(
-      {
-        provider: this.provider,
-        cwd: overrides?.cwd ?? process.cwd(),
-        ...overrides,
-      },
-      this.provider,
-      this.behavior,
-    );
-  }
-
-  async listModels(_options?: ListModelsOptions): Promise<AgentModelDefinition[]> {
-    return [];
-  }
-}
-
-class ScriptedAgentSession implements AgentSession {
-  readonly capabilities = TEST_CAPABILITIES;
-  readonly id = randomUUID();
-  private readonly subscribers = new Set<(event: AgentStreamEvent) => void>();
-  private turnCount = 0;
-  private interrupted = false;
-
-  constructor(
-    private readonly config: AgentSessionConfig,
-    readonly provider: AgentProvider,
-    private readonly behavior: ScriptedAgentBehavior,
-  ) {}
-
-  async run(): Promise<AgentRunResult> {
-    return {
-      sessionId: this.id,
-      finalText: "",
-      timeline: [],
-    };
-  }
-
-  async startTurn(prompt: AgentPromptInput, _options?: AgentRunOptions): Promise<{ turnId: string }> {
-    const promptText = typeof prompt === "string" ? prompt : JSON.stringify(prompt);
-    const turnId = `turn-${++this.turnCount}`;
-    this.interrupted = false;
-    setTimeout(() => {
-      void this.runScript(promptText, turnId);
-    }, 0);
-    return { turnId };
-  }
-
-  subscribe(callback: (event: AgentStreamEvent) => void): () => void {
-    this.subscribers.add(callback);
-    return () => {
-      this.subscribers.delete(callback);
-    };
-  }
-
-  async *streamHistory(): AsyncGenerator<AgentStreamEvent> {}
-
-  async getRuntimeInfo(): Promise<AgentRuntimeInfo> {
-    return {
-      provider: this.provider,
-      sessionId: this.id,
-      model: this.config.model ?? null,
-      modeId: this.config.modeId ?? null,
-    };
-  }
-
-  async getAvailableModes(): Promise<AgentMode[]> {
-    return [];
-  }
-
-  async getCurrentMode(): Promise<string | null> {
-    return this.config.modeId ?? null;
-  }
-
-  async setMode(): Promise<void> {}
-
-  getPendingPermissions() {
-    return [];
-  }
-
-  async respondToPermission(): Promise<void> {}
-
-  describePersistence(): AgentPersistenceHandle {
-    return {
-      provider: this.provider,
-      sessionId: this.id,
-    };
-  }
-
-  async interrupt(): Promise<void> {
-    this.interrupted = true;
-  }
-
-  async close(): Promise<void> {}
-
-  async listCommands(): Promise<AgentSlashCommand[]> {
-    return [];
-  }
-
-  private emit(event: AgentStreamEvent): void {
-    for (const subscriber of this.subscribers) {
-      subscriber(event);
-    }
-  }
-
-  private async runScript(prompt: string, turnId: string): Promise<void> {
-    this.emit({ type: "turn_started", provider: this.provider, turnId });
-    if (this.interrupted) {
-      this.emit({ type: "turn_canceled", provider: this.provider, reason: "interrupted", turnId });
-      return;
-    }
-
-    try {
-      const responseText = await this.behavior.onRun({
-        config: this.config,
-        prompt,
-        turnId,
-      });
-      if (this.interrupted) {
-        this.emit({ type: "turn_canceled", provider: this.provider, reason: "interrupted", turnId });
-        return;
-      }
-      this.emit({
-        type: "timeline",
-        provider: this.provider,
-        turnId,
-        item: { type: "assistant_message", text: responseText },
-      });
-      this.emit({ type: "turn_completed", provider: this.provider, turnId });
-    } catch (error) {
-      this.emit({
-        type: "turn_failed",
-        provider: this.provider,
-        turnId,
-        error: error instanceof Error ? error.message : String(error),
-      });
-    }
-  }
-}
-
-describe("LoopService", () => {
-  const logger = createTestLogger();
-  let tmpDir: string;
-  let paseoHome: string;
-  let workspaceDir: string;
-  let storage: AgentStorage;
-
-  beforeEach(() => {
-    tmpDir = mkdtempSync(path.join(os.tmpdir(), "loop-service-"));
-    paseoHome = path.join(tmpDir, "paseo-home");
-    workspaceDir = path.join(tmpDir, "workspace");
-    storage = new AgentStorage(path.join(tmpDir, "agents"), logger);
-    mkdirSync(workspaceDir, { recursive: true });
-  });
-
-  afterEach(() => {
-    rmSync(tmpDir, { recursive: true, force: true });
-  });
-
-  test("runs fresh worker agents until verify-check passes", async () => {
-    const state = { workerRuns: 0 };
-    const manager = new AgentManager({
-      clients: {
-        claude: new ScriptedAgentClient("claude", {
-          async onRun({ config }) {
-            state.workerRuns += 1;
-            if (config.title?.includes("worker") && state.workerRuns >= 2) {
-              writeFileSync(path.join(workspaceDir, "done.txt"), "ok");
-            }
-            if (config.title?.includes("worker")) {
-              return `worker run ${state.workerRuns}`;
-            }
-            return "{\"passed\":true,\"reason\":\"not used\"}";
-          },
-        }),
-      },
-      registry: storage,
-      logger,
-    });
-    const service = new LoopService({ paseoHome, agentManager: manager, logger });
-    await service.initialize();
-
-    const loop = await service.runLoop({
-      prompt: "Create done.txt when the task is actually fixed.",
-      cwd: workspaceDir,
-      verifyChecks: ["test -f done.txt"],
-      sleepMs: 1,
-      maxIterations: 3,
-    });
-
-    await waitForLoopCompletion(service, loop.id);
-
-    const finalLoop = await service.inspectLoop(loop.id);
-    expect(finalLoop.status).toBe("succeeded");
-    expect(finalLoop.iterations).toHaveLength(2);
-    expect(finalLoop.iterations[0]?.workerAgentId).not.toBe(finalLoop.iterations[1]?.workerAgentId);
-    expect(finalLoop.iterations[0]?.status).toBe("failed");
-    expect(finalLoop.iterations[1]?.status).toBe("succeeded");
-    expect(finalLoop.iterations[0]?.verifyChecks[0]?.passed).toBe(false);
-    expect(finalLoop.iterations[1]?.verifyChecks[0]?.passed).toBe(true);
-    expect(readFileSync(path.join(paseoHome, "loops", "loops.json"), "utf8")).toContain(loop.id);
-  });
-
-  test("uses worker and verifier provider-model settings when provided", async () => {
-    const workerConfigs: AgentSessionConfig[] = [];
-    const verifierConfigs: AgentSessionConfig[] = [];
-    const manager = new AgentManager({
-      clients: {
-        codex: new ScriptedAgentClient("codex", {
-          async onRun({ config }) {
-            workerConfigs.push(config);
-            writeFileSync(path.join(workspaceDir, "done.txt"), "ok");
-            return "done";
-          },
-        }),
-        claude: new ScriptedAgentClient("claude", {
-          async onRun({ config }) {
-            verifierConfigs.push(config);
-            return "{\"passed\":true,\"reason\":\"verified\"}";
-          },
-        }),
-      },
-      registry: storage,
-      logger,
-    });
-    const service = new LoopService({ paseoHome, agentManager: manager, logger });
-    await service.initialize();
-
-    const loop = await service.runLoop({
-      prompt: "Create done.txt",
-      cwd: workspaceDir,
-      provider: "codex",
-      model: "fallback-model",
-      workerModel: "gpt-5.4",
-      verifyPrompt: "Confirm that done.txt exists in the workspace.",
-      verifierProvider: "claude",
-      verifierModel: "sonnet",
-      maxIterations: 1,
-    });
-
-    await waitForLoopCompletion(service, loop.id);
-
-    const finalLoop = await service.inspectLoop(loop.id);
-    expect(finalLoop.status).toBe("succeeded");
-    expect(finalLoop.provider).toBe("codex");
-    expect(finalLoop.model).toBe("fallback-model");
-    expect(finalLoop.workerProvider).toBeNull();
-    expect(finalLoop.workerModel).toBe("gpt-5.4");
-    expect(finalLoop.verifierProvider).toBe("claude");
-    expect(finalLoop.verifierModel).toBe("sonnet");
-    expect(workerConfigs).toHaveLength(1);
-    expect(workerConfigs[0]).toMatchObject({
-      provider: "codex",
-      model: "gpt-5.4",
-      internal: true,
-    });
-    expect(verifierConfigs).toHaveLength(1);
-    expect(verifierConfigs[0]).toMatchObject({
-      provider: "claude",
-      model: "sonnet",
-      internal: true,
-    });
-  });
-
-  test("archives worker and verifier agents after each iteration when requested", async () => {
-    const archivedAgentIds: string[] = [];
-    const manager = new AgentManager({
-      clients: {
-        claude: new ScriptedAgentClient("claude", {
-          async onRun({ config }) {
-            if (config.title?.includes("worker")) {
-              writeFileSync(path.join(workspaceDir, "done.txt"), "ok");
-              return "created done.txt";
-            }
-            return "{\"passed\":true,\"reason\":\"done.txt exists\"}";
-          },
-        }),
-      },
-      registry: storage,
-      logger,
-    });
-    const archiveAgent = manager.archiveAgent.bind(manager);
-    manager.archiveAgent = async (agentId) => {
-      archivedAgentIds.push(agentId);
-      await archiveAgent(agentId);
-    };
-    const service = new LoopService({ paseoHome, agentManager: manager, logger });
-    await service.initialize();
-
-    const loop = await service.runLoop({
-      prompt: "Create done.txt",
-      cwd: workspaceDir,
-      verifyPrompt: "Confirm that done.txt exists in the workspace.",
-      archive: true,
-      maxIterations: 1,
-    });
-
-    await waitForLoopCompletion(service, loop.id);
-
-    const finalLoop = await service.inspectLoop(loop.id);
-    const iteration = finalLoop.iterations[0];
-    expect(finalLoop.archive).toBe(true);
-    expect(iteration?.workerAgentId).toBeTruthy();
-    expect(iteration?.verifierAgentId).toBeTruthy();
-    expect(archivedAgentIds).toEqual([iteration!.workerAgentId!, iteration!.verifierAgentId!]);
-    await storage.flush();
-    await expect(storage.get(iteration!.workerAgentId!)).resolves.toMatchObject({
-      id: iteration!.workerAgentId!,
-      archivedAt: expect.any(String),
-      internal: true,
-    });
-    await expect(storage.get(iteration!.verifierAgentId!)).resolves.toMatchObject({
-      id: iteration!.verifierAgentId!,
-      archivedAt: expect.any(String),
-      internal: true,
-    });
-  });
-
-  test("uses verifier prompt when provided", async () => {
-    const manager = new AgentManager({
-      clients: {
-        claude: new ScriptedAgentClient("claude", {
-          async onRun({ config }) {
-            if (config.title?.includes("worker")) {
-              await fsMkdir(workspaceDir);
-              writeFileSync(path.join(workspaceDir, "done.txt"), "ok");
-              return "created done.txt";
-            }
-            const exists = pathExists(path.join(workspaceDir, "done.txt"));
-            return exists
-              ? "{\"passed\":true,\"reason\":\"done.txt exists\"}"
-              : "{\"passed\":false,\"reason\":\"done.txt missing\"}";
-          },
-        }),
-      },
-      registry: storage,
-      logger,
-    });
-    const service = new LoopService({ paseoHome, agentManager: manager, logger });
-    await service.initialize();
-
-    const loop = await service.runLoop({
-      prompt: "Create done.txt",
-      cwd: workspaceDir,
-      verifyPrompt: "Confirm that done.txt exists in the workspace.",
-      maxIterations: 1,
-    });
-
-    await waitForLoopCompletion(service, loop.id);
-
-    const finalLoop = await service.inspectLoop(loop.id);
-    expect(finalLoop.status).toBe("succeeded");
-    expect(finalLoop.iterations[0]?.verifyPrompt).toMatchObject({
-      passed: true,
-      reason: "done.txt exists",
-    });
-    const logs = await service.getLoopLogs(loop.id);
-    expect(logs.entries.some((entry) => entry.text.includes("Verifier result"))).toBe(true);
-  });
-
-  test("stops a running loop and cancels the active worker", async () => {
-    let release: (() => void) | null = null;
-    const blocker = new Promise<void>((resolve) => {
-      release = resolve;
-    });
-    const manager = new AgentManager({
-      clients: {
-        claude: new ScriptedAgentClient("claude", {
-          async onRun({ config }) {
-            if (config.title?.includes("worker")) {
-              await blocker;
-              return "finished";
-            }
-            return "{\"passed\":true,\"reason\":\"ok\"}";
-          },
-        }),
-      },
-      registry: storage,
-      logger,
-    });
-    const service = new LoopService({ paseoHome, agentManager: manager, logger });
-    await service.initialize();
-
-    const loop = await service.runLoop({
-      prompt: "Wait forever",
-      cwd: workspaceDir,
-      verifyChecks: ["test -f never.txt"],
-    });
-
-    await new Promise((resolve) => setTimeout(resolve, 25));
-    const stopped = await service.stopLoop(loop.id);
-    release?.();
-
-    expect(stopped.status).toBe("stopped");
-    const finalLoop = await service.inspectLoop(loop.id);
-    expect(finalLoop.status).toBe("stopped");
-    expect(finalLoop.iterations[0]?.status).toBe("stopped");
-    expect(finalLoop.logs.some((entry) => entry.text.includes("Stop requested"))).toBe(true);
-  });
-});
-
-async function fsMkdir(target: string): Promise<void> {
-  await import("node:fs/promises").then(({ mkdir }) => mkdir(target, { recursive: true }));
-}
-
-function pathExists(target: string): boolean {
-  return existsSync(target);
-}
-
-async function waitForLoopCompletion(service: LoopService, loopId: string): Promise<void> {
-  while ((await service.inspectLoop(loopId)).status === "running") {
-    await new Promise((resolve) => setTimeout(resolve, 10));
-  }
-}

packages/server/src/server/loop-service.ts

@@ -1,876 +0,0 @@
-import { randomUUID } from "node:crypto";
-import { execFile } from "node:child_process";
-import { promises as fs } from "node:fs";
-import path from "node:path";
-import { promisify } from "node:util";
-import { z } from "zod";
-import type { Logger } from "pino";
-import { curateAgentActivity } from "./agent/activity-curator.js";
-import type { AgentManager } from "./agent/agent-manager.js";
-import { getStructuredAgentResponse } from "./agent/agent-response-loop.js";
-import type {
-  AgentPromptInput,
-  AgentSessionConfig,
-  AgentStreamEvent,
-  AgentTimelineItem,
-  AgentProvider,
-} from "./agent/agent-sdk-types.js";
-
-const execFileAsync = promisify(execFile);
-const LOOP_ID_LENGTH = 8;
-const DEFAULT_LOOP_PROVIDER: AgentProvider = "claude";
-const MAX_VERIFY_OUTPUT_BYTES = 64 * 1024;
-
-const LoopVerifyPromptSchema = z.object({
-  passed: z.boolean(),
-  reason: z.string().min(1),
-});
-
-const LoopLogEntrySchema = z.object({
-  seq: z.number().int().positive(),
-  timestamp: z.string(),
-  iteration: z.number().int().positive().nullable(),
-  source: z.enum(["loop", "worker", "verifier", "verify-check"]),
-  level: z.enum(["info", "error"]),
-  text: z.string(),
-});
-
-const LoopVerifyCheckResultSchema = z.object({
-  command: z.string(),
-  exitCode: z.number().int(),
-  passed: z.boolean(),
-  stdout: z.string(),
-  stderr: z.string(),
-  startedAt: z.string(),
-  completedAt: z.string(),
-});
-
-const LoopVerifyPromptResultSchema = z.object({
-  passed: z.boolean(),
-  reason: z.string(),
-  verifierAgentId: z.string().nullable(),
-  startedAt: z.string(),
-  completedAt: z.string(),
-});
-
-const LoopIterationRecordSchema = z.object({
-  index: z.number().int().positive(),
-  workerAgentId: z.string().nullable(),
-  workerStartedAt: z.string(),
-  workerCompletedAt: z.string().nullable(),
-  verifierAgentId: z.string().nullable(),
-  status: z.enum(["running", "succeeded", "failed", "stopped"]),
-  workerOutcome: z.enum(["completed", "failed", "canceled"]).nullable(),
-  failureReason: z.string().nullable(),
-  verifyChecks: z.array(LoopVerifyCheckResultSchema),
-  verifyPrompt: LoopVerifyPromptResultSchema.nullable(),
-});
-
-const LoopRecordSchema = z.object({
-  id: z.string(),
-  name: z.string().nullable(),
-  prompt: z.string(),
-  cwd: z.string(),
-  provider: z.enum(["claude", "codex", "opencode"]),
-  model: z.string().nullable(),
-  workerProvider: z.enum(["claude", "codex", "opencode"]).nullable(),
-  workerModel: z.string().nullable(),
-  verifierProvider: z.enum(["claude", "codex", "opencode"]).nullable(),
-  verifierModel: z.string().nullable(),
-  verifyPrompt: z.string().nullable(),
-  verifyChecks: z.array(z.string()),
-  archive: z.boolean(),
-  sleepMs: z.number().int().nonnegative(),
-  maxIterations: z.number().int().positive().nullable(),
-  maxTimeMs: z.number().int().positive().nullable(),
-  status: z.enum(["running", "succeeded", "failed", "stopped"]),
-  createdAt: z.string(),
-  updatedAt: z.string(),
-  startedAt: z.string(),
-  completedAt: z.string().nullable(),
-  stopRequestedAt: z.string().nullable(),
-  iterations: z.array(LoopIterationRecordSchema),
-  logs: z.array(LoopLogEntrySchema),
-  nextLogSeq: z.number().int().positive(),
-  activeIteration: z.number().int().positive().nullable(),
-  activeWorkerAgentId: z.string().nullable(),
-  activeVerifierAgentId: z.string().nullable(),
-});
-
-const StoredLoopsSchema = z.array(LoopRecordSchema);
-
-export type LoopStatus = z.infer<typeof LoopRecordSchema>["status"];
-export type LoopLogEntry = z.infer<typeof LoopLogEntrySchema>;
-export type LoopVerifyCheckResult = z.infer<typeof LoopVerifyCheckResultSchema>;
-export type LoopVerifyPromptResult = z.infer<typeof LoopVerifyPromptResultSchema>;
-export type LoopIterationRecord = z.infer<typeof LoopIterationRecordSchema>;
-export type LoopRecord = z.infer<typeof LoopRecordSchema>;
-
-export interface LoopRunOptions {
-  prompt: string;
-  cwd: string;
-  provider?: AgentProvider;
-  model?: string;
-  workerProvider?: AgentProvider;
-  workerModel?: string;
-  verifierProvider?: AgentProvider;
-  verifierModel?: string;
-  verifyPrompt?: string;
-  verifyChecks?: string[];
-  archive?: boolean;
-  name?: string;
-  sleepMs?: number;
-  maxIterations?: number;
-  maxTimeMs?: number;
-}
-
-export interface LoopListItem {
-  id: string;
-  name: string | null;
-  status: LoopStatus;
-  cwd: string;
-  createdAt: string;
-  updatedAt: string;
-  activeIteration: number | null;
-}
-
-export interface LoopLogsResult {
-  loop: LoopRecord;
-  entries: LoopLogEntry[];
-  nextCursor: number;
-}
-
-interface RunningLoopState {
-  abortController: AbortController;
-  promise: Promise<void>;
-}
-
-function nowIso(): string {
-  return new Date().toISOString();
-}
-
-function cloneLoop(record: LoopRecord): LoopRecord {
-  return LoopRecordSchema.parse(record);
-}
-
-function createLoopId(): string {
-  return randomUUID().replace(/-/g, "").slice(0, LOOP_ID_LENGTH);
-}
-
-function normalizeName(name: string | undefined): string | null {
-  const trimmed = name?.trim();
-  return trimmed ? trimmed : null;
-}
-
-function normalizePrompt(value: string | undefined, field: string): string | null {
-  if (value === undefined) {
-    return null;
-  }
-  const trimmed = value.trim();
-  if (!trimmed) {
-    throw new Error(`${field} cannot be empty`);
-  }
-  return trimmed;
-}
-
-function ensurePositiveInteger(value: number | undefined, field: string): number | null {
-  if (value === undefined) {
-    return null;
-  }
-  if (!Number.isInteger(value) || value <= 0) {
-    throw new Error(`${field} must be a positive integer`);
-  }
-  return value;
-}
-
-function ensureNonNegativeInteger(value: number | undefined, field: string): number {
-  if (value === undefined) {
-    return 0;
-  }
-  if (!Number.isInteger(value) || value < 0) {
-    throw new Error(`${field} must be a non-negative integer`);
-  }
-  return value;
-}
-
-function buildWorkerTitle(loop: LoopRecord, iterationIndex: number): string {
-  const prefix = loop.name ?? loop.id;
-  return `${prefix} [loop ${iterationIndex} worker]`;
-}
-
-function buildVerifierTitle(loop: LoopRecord, iterationIndex: number): string {
-  const prefix = loop.name ?? loop.id;
-  return `${prefix} [loop ${iterationIndex} verifier]`;
-}
-
-function formatStreamLog(event: AgentStreamEvent): string | null {
-  switch (event.type) {
-    case "timeline": {
-      const rendered = curateAgentActivity([event.item]);
-      return rendered === "No activity to display." ? null : rendered;
-    }
-    case "turn_failed":
-      return `[Turn Failed] ${event.error}`;
-    case "turn_canceled":
-      return `[Turn Canceled] ${event.reason}`;
-    case "permission_requested":
-      return `[Permission Requested] ${event.request.name}`;
-    case "permission_resolved":
-      return `[Permission Resolved] ${event.requestId}`;
-    default:
-      return null;
-  }
-}
-
-async function sleepWithAbort(ms: number, signal: AbortSignal): Promise<void> {
-  if (ms <= 0) {
-    return;
-  }
-  await new Promise<void>((resolve, reject) => {
-    const timer = setTimeout(() => {
-      cleanup();
-      resolve();
-    }, ms);
-    const onAbort = () => {
-      cleanup();
-      reject(signal.reason instanceof Error ? signal.reason : new Error("Loop aborted"));
-    };
-    const cleanup = () => {
-      clearTimeout(timer);
-      signal.removeEventListener("abort", onAbort);
-    };
-    signal.addEventListener("abort", onAbort, { once: true });
-  });
-}
-
-function isAbortError(error: unknown): boolean {
-  if (error instanceof Error && error.message === "Loop aborted") {
-    return true;
-  }
-  return false;
-}
-
-async function runVerifyCheck(options: {
-  cwd: string;
-  command: string;
-}): Promise<LoopVerifyCheckResult> {
-  const startedAt = nowIso();
-  try {
-    const result = await execFileAsync("/bin/zsh", ["-lc", options.command], {
-      cwd: options.cwd,
-      maxBuffer: MAX_VERIFY_OUTPUT_BYTES,
-    });
-    return {
-      command: options.command,
-      exitCode: 0,
-      passed: true,
-      stdout: result.stdout ?? "",
-      stderr: result.stderr ?? "",
-      startedAt,
-      completedAt: nowIso(),
-    };
-  } catch (error) {
-    const childError = error as Error & {
-      code?: number | string;
-      stdout?: string;
-      stderr?: string;
-    };
-    return {
-      command: options.command,
-      exitCode: typeof childError.code === "number" ? childError.code : 1,
-      passed: false,
-      stdout: childError.stdout ?? "",
-      stderr: childError.stderr ?? "",
-      startedAt,
-      completedAt: nowIso(),
-    };
-  }
-}
-
-export class LoopService {
-  private readonly storePath: string;
-  private readonly logger: Logger;
-  private loaded = false;
-  private readonly loops = new Map<string, LoopRecord>();
-  private persistQueue: Promise<void> = Promise.resolve();
-  private readonly running = new Map<string, RunningLoopState>();
-
-  constructor(
-    private readonly options: {
-      paseoHome: string;
-      agentManager: AgentManager;
-      logger: Logger;
-    },
-  ) {
-    this.storePath = path.join(options.paseoHome, "loops", "loops.json");
-    this.logger = options.logger.child({ module: "loop-service" });
-  }
-
-  async initialize(): Promise<void> {
-    if (this.loaded) {
-      return;
-    }
-    this.loops.clear();
-    try {
-      const raw = await fs.readFile(this.storePath, "utf8");
-      const parsed = StoredLoopsSchema.parse(JSON.parse(raw));
-      for (const record of parsed) {
-        if (record.status === "running") {
-          const recovered = cloneLoop(record);
-          recovered.status = "stopped";
-          recovered.updatedAt = nowIso();
-          recovered.completedAt = recovered.updatedAt;
-          recovered.stopRequestedAt = recovered.updatedAt;
-          recovered.activeIteration = null;
-          recovered.activeWorkerAgentId = null;
-          recovered.activeVerifierAgentId = null;
-          this.appendLog(recovered, {
-            iteration: null,
-            source: "loop",
-            level: "error",
-            text: "Loop was interrupted by daemon restart.",
-          });
-          const lastIteration = recovered.iterations.at(-1);
-          if (lastIteration && lastIteration.status === "running") {
-            lastIteration.status = "stopped";
-            lastIteration.failureReason = "Daemon restarted";
-            lastIteration.workerCompletedAt = recovered.updatedAt;
-          }
-          this.loops.set(recovered.id, recovered);
-          continue;
-        }
-        this.loops.set(record.id, record);
-      }
-    } catch (error) {
-      const code = (error as NodeJS.ErrnoException).code;
-      if (code !== "ENOENT") {
-        this.logger.error({ err: error, storePath: this.storePath }, "Failed to load loops");
-      }
-    }
-    this.loaded = true;
-    await this.persist();
-  }
-
-  async runLoop(input: LoopRunOptions): Promise<LoopRecord> {
-    await this.initialize();
-    const prompt = normalizePrompt(input.prompt, "prompt");
-    if (!prompt) {
-      throw new Error("prompt cannot be empty");
-    }
-    const verifyPrompt = normalizePrompt(input.verifyPrompt, "verifyPrompt");
-    const verifyChecks = (input.verifyChecks ?? []).map((command) => {
-      const trimmed = command.trim();
-      if (!trimmed) {
-        throw new Error("verifyChecks cannot contain empty commands");
-      }
-      return trimmed;
-    });
-    if (!verifyPrompt && verifyChecks.length === 0) {
-      throw new Error("Loop requires --verify or at least one --verify-check");
-    }
-
-    const createdAt = nowIso();
-    const record = LoopRecordSchema.parse({
-      id: createLoopId(),
-      name: normalizeName(input.name),
-      prompt,
-      cwd: path.resolve(input.cwd),
-      provider: input.provider ?? DEFAULT_LOOP_PROVIDER,
-      model: normalizePrompt(input.model, "model"),
-      workerProvider: input.workerProvider ?? null,
-      workerModel: normalizePrompt(input.workerModel, "workerModel"),
-      verifierProvider: input.verifierProvider ?? null,
-      verifierModel: normalizePrompt(input.verifierModel, "verifierModel"),
-      verifyPrompt,
-      verifyChecks,
-      archive: input.archive ?? false,
-      sleepMs: ensureNonNegativeInteger(input.sleepMs, "sleepMs"),
-      maxIterations: ensurePositiveInteger(input.maxIterations, "maxIterations"),
-      maxTimeMs: ensurePositiveInteger(input.maxTimeMs, "maxTimeMs"),
-      status: "running",
-      createdAt,
-      updatedAt: createdAt,
-      startedAt: createdAt,
-      completedAt: null,
-      stopRequestedAt: null,
-      iterations: [],
-      logs: [],
-      nextLogSeq: 1,
-      activeIteration: null,
-      activeWorkerAgentId: null,
-      activeVerifierAgentId: null,
-    });
-
-    this.loops.set(record.id, record);
-    this.appendLog(record, {
-      iteration: null,
-      source: "loop",
-      level: "info",
-      text: `Loop created in ${record.cwd}`,
-    });
-    await this.persist();
-
-    const abortController = new AbortController();
-    const promise = this.executeLoop(record.id, abortController.signal).finally(() => {
-      this.running.delete(record.id);
-    });
-    this.running.set(record.id, { abortController, promise });
-
-    return cloneLoop(record);
-  }
-
-  async listLoops(): Promise<LoopListItem[]> {
-    await this.initialize();
-    return Array.from(this.loops.values())
-      .sort((left, right) => right.createdAt.localeCompare(left.createdAt))
-      .map((record) => ({
-        id: record.id,
-        name: record.name,
-        status: record.status,
-        cwd: record.cwd,
-        createdAt: record.createdAt,
-        updatedAt: record.updatedAt,
-        activeIteration: record.activeIteration,
-      }));
-  }
-
-  async inspectLoop(idOrPrefix: string): Promise<LoopRecord> {
-    await this.initialize();
-    const loop = this.requireLoop(idOrPrefix);
-    return cloneLoop(loop);
-  }
-
-  async getLoopLogs(idOrPrefix: string, afterSeq = 0): Promise<LoopLogsResult> {
-    await this.initialize();
-    const loop = this.requireLoop(idOrPrefix);
-    const entries = loop.logs.filter((entry) => entry.seq > afterSeq);
-    return {
-      loop: cloneLoop(loop),
-      entries: entries.map((entry) => LoopLogEntrySchema.parse(entry)),
-      nextCursor: loop.nextLogSeq - 1,
-    };
-  }
-
-  async stopLoop(idOrPrefix: string): Promise<LoopRecord> {
-    await this.initialize();
-    const loop = this.requireLoop(idOrPrefix);
-    if (loop.status !== "running") {
-      return cloneLoop(loop);
-    }
-    const running = this.running.get(loop.id);
-    loop.stopRequestedAt = loop.stopRequestedAt ?? nowIso();
-    loop.updatedAt = loop.stopRequestedAt;
-    this.appendLog(loop, {
-      iteration: loop.activeIteration,
-      source: "loop",
-      level: "info",
-      text: "Stop requested.",
-    });
-    await this.persist();
-
-    if (running) {
-      running.abortController.abort(new Error("Loop aborted"));
-      if (loop.activeWorkerAgentId) {
-        await this.options.agentManager.cancelAgentRun(loop.activeWorkerAgentId).catch(() => {});
-      }
-      if (loop.activeVerifierAgentId) {
-        await this.options.agentManager.cancelAgentRun(loop.activeVerifierAgentId).catch(() => {});
-      }
-      await running.promise.catch(() => {});
-    } else {
-      loop.status = "stopped";
-      loop.completedAt = nowIso();
-      loop.updatedAt = loop.completedAt;
-      await this.persist();
-    }
-
-    return cloneLoop(loop);
-  }
-
-  private async executeLoop(loopId: string, signal: AbortSignal): Promise<void> {
-    const loop = this.requireLoop(loopId);
-    const deadline = loop.maxTimeMs ? Date.now() + loop.maxTimeMs : null;
-
-    try {
-      for (let index = 1; ; index += 1) {
-        if (signal.aborted) {
-          throw new Error("Loop aborted");
-        }
-        if (loop.maxIterations && index > loop.maxIterations) {
-          this.finishLoop(loop, "failed", `Reached max iterations (${loop.maxIterations}).`);
-          return;
-        }
-        if (deadline !== null && Date.now() > deadline) {
-          this.finishLoop(loop, "failed", `Reached max time (${loop.maxTimeMs}ms).`);
-          return;
-        }
-
-        const iteration = LoopIterationRecordSchema.parse({
-          index,
-          workerAgentId: null,
-          workerStartedAt: nowIso(),
-          workerCompletedAt: null,
-          verifierAgentId: null,
-          status: "running",
-          workerOutcome: null,
-          failureReason: null,
-          verifyChecks: [],
-          verifyPrompt: null,
-        });
-        loop.iterations.push(iteration);
-        loop.activeIteration = index;
-        loop.updatedAt = nowIso();
-        this.appendLog(loop, {
-          iteration: index,
-          source: "loop",
-          level: "info",
-          text: `Starting iteration ${index}.`,
-        });
-        await this.persist();
-
-        const workerPassed = await this.runWorkerIteration(loop, iteration, signal);
-        if (signal.aborted) {
-          throw new Error("Loop aborted");
-        }
-        if (!workerPassed) {
-          iteration.status = iteration.status === "stopped" ? "stopped" : "failed";
-        } else {
-          const verificationPassed = await this.runVerification(loop, iteration, signal);
-          if (verificationPassed) {
-            iteration.status = "succeeded";
-            this.finishLoop(loop, "succeeded", `Iteration ${index} passed verification.`);
-            return;
-          }
-          if (iteration.status === "running") {
-            iteration.status = "failed";
-          }
-        }
-
-        loop.activeIteration = null;
-        loop.activeWorkerAgentId = null;
-        loop.activeVerifierAgentId = null;
-        loop.updatedAt = nowIso();
-        await this.persist();
-
-        if (loop.sleepMs > 0) {
-          this.appendLog(loop, {
-            iteration: index,
-            source: "loop",
-            level: "info",
-            text: `Sleeping ${loop.sleepMs}ms before next iteration.`,
-          });
-          await this.persist();
-          await sleepWithAbort(loop.sleepMs, signal);
-        }
-      }
-    } catch (error) {
-      if (isAbortError(error)) {
-        this.finishLoop(loop, "stopped", "Loop stopped.");
-        const iteration = loop.activeIteration
-          ? loop.iterations.find((candidate) => candidate.index === loop.activeIteration)
-          : null;
-        if (iteration && iteration.status === "running") {
-          iteration.status = "stopped";
-          iteration.failureReason = "Loop stopped";
-          iteration.workerCompletedAt = nowIso();
-        }
-        await this.persist();
-        return;
-      }
-
-      const message = error instanceof Error ? error.message : String(error);
-      this.logger.error({ err: error, loopId }, "Loop execution failed");
-      this.finishLoop(loop, "failed", message);
-      const iteration = loop.activeIteration
-        ? loop.iterations.find((candidate) => candidate.index === loop.activeIteration)
-        : null;
-      if (iteration && iteration.status === "running") {
-        iteration.status = "failed";
-        iteration.failureReason = message;
-        iteration.workerCompletedAt = nowIso();
-      }
-      await this.persist();
-    }
-  }
-
-  private async runWorkerIteration(
-    loop: LoopRecord,
-    iteration: LoopIterationRecord,
-    signal: AbortSignal,
-  ): Promise<boolean> {
-    const agent = await this.options.agentManager.createAgent(this.buildWorkerConfig(loop, iteration));
-    iteration.workerAgentId = agent.id;
-    loop.activeWorkerAgentId = agent.id;
-    loop.updatedAt = nowIso();
-    await this.persist();
-
-    const unsubscribe = this.options.agentManager.subscribe(
-      (event) => {
-        if (event.type !== "agent_stream") {
-          return;
-        }
-        const text = formatStreamLog(event.event);
-        if (!text) {
-          return;
-        }
-        this.appendLog(loop, {
-          iteration: iteration.index,
-          source: "worker",
-          level: event.event.type === "turn_failed" ? "error" : "info",
-          text,
-        });
-        void this.persist();
-      },
-      { agentId: agent.id, replayState: false },
-    );
-
-    try {
-      const prompt = this.toPrompt(loop.prompt);
-      const result = await this.options.agentManager.runAgent(agent.id, prompt);
-      iteration.workerCompletedAt = nowIso();
-      iteration.workerOutcome = result.canceled ? "canceled" : "completed";
-      if (result.canceled) {
-        iteration.failureReason = "Worker run was canceled.";
-        iteration.status = "stopped";
-        return false;
-      }
-      return true;
-    } catch (error) {
-      iteration.workerCompletedAt = nowIso();
-      iteration.workerOutcome = "failed";
-      iteration.failureReason = error instanceof Error ? error.message : String(error);
-      this.appendLog(loop, {
-        iteration: iteration.index,
-        source: "loop",
-        level: "error",
-        text: `Worker failed: ${iteration.failureReason}`,
-      });
-      return false;
-    } finally {
-      unsubscribe();
-      loop.activeWorkerAgentId = null;
-      loop.updatedAt = nowIso();
-      await this.persist();
-      try {
-        if (loop.archive) {
-          await this.options.agentManager.archiveAgent(agent.id);
-        } else {
-          await this.options.agentManager.closeAgent(agent.id);
-        }
-      } catch {
-        // Ignore cleanup errors for internal loop workers.
-      }
-      if (signal.aborted && iteration.status === "running") {
-        iteration.status = "stopped";
-      }
-    }
-  }
-
-  private async runVerification(
-    loop: LoopRecord,
-    iteration: LoopIterationRecord,
-    signal: AbortSignal,
-  ): Promise<boolean> {
-    for (const command of loop.verifyChecks) {
-      if (signal.aborted) {
-        throw new Error("Loop aborted");
-      }
-      this.appendLog(loop, {
-        iteration: iteration.index,
-        source: "verify-check",
-        level: "info",
-        text: `$ ${command}`,
-      });
-      const result = await runVerifyCheck({ cwd: loop.cwd, command });
-      iteration.verifyChecks.push(result);
-      const output = [result.stdout.trim(), result.stderr.trim()].filter(Boolean).join("\n");
-      this.appendLog(loop, {
-        iteration: iteration.index,
-        source: "verify-check",
-        level: result.passed ? "info" : "error",
-        text: output
-          ? `exit ${result.exitCode}\n${output}`
-          : `exit ${result.exitCode}`,
-      });
-      loop.updatedAt = nowIso();
-      await this.persist();
-      if (!result.passed) {
-        iteration.failureReason = `Verify check failed: ${command}`;
-        return false;
-      }
-    }
-
-    if (!loop.verifyPrompt) {
-      return true;
-    }
-
-    const startedAt = nowIso();
-    const verifierAgent = await this.options.agentManager.createAgent(
-      this.buildVerifierConfig(loop, iteration),
-    );
-    iteration.verifierAgentId = verifierAgent.id;
-    loop.activeVerifierAgentId = verifierAgent.id;
-    loop.updatedAt = nowIso();
-    await this.persist();
-
-    const unsubscribe = this.options.agentManager.subscribe(
-      (event) => {
-        if (event.type !== "agent_stream") {
-          return;
-        }
-        const text = formatStreamLog(event.event);
-        if (!text) {
-          return;
-        }
-        this.appendLog(loop, {
-          iteration: iteration.index,
-          source: "verifier",
-          level: event.event.type === "turn_failed" ? "error" : "info",
-          text,
-        });
-        void this.persist();
-      },
-      { agentId: verifierAgent.id, replayState: false },
-    );
-
-    try {
-      const result = await getStructuredAgentResponse({
-        caller: async (nextPrompt) => {
-          const run = await this.options.agentManager.runAgent(verifierAgent.id, this.toPrompt(nextPrompt));
-          return this.resolveFinalText(run.timeline, run.finalText);
-        },
-        prompt: loop.verifyPrompt,
-        schema: LoopVerifyPromptSchema,
-        maxRetries: 2,
-        schemaName: "LoopVerifierResult",
-      });
-      iteration.verifyPrompt = {
-        passed: result.passed,
-        reason: result.reason,
-        verifierAgentId: verifierAgent.id,
-        startedAt,
-        completedAt: nowIso(),
-      };
-      this.appendLog(loop, {
-        iteration: iteration.index,
-        source: "loop",
-        level: result.passed ? "info" : "error",
-        text: `Verifier result: ${result.reason}`,
-      });
-      if (!result.passed) {
-        iteration.failureReason = result.reason;
-      }
-      return result.passed;
-    } finally {
-      unsubscribe();
-      loop.activeVerifierAgentId = null;
-      loop.updatedAt = nowIso();
-      await this.persist();
-      try {
-        if (loop.archive) {
-          await this.options.agentManager.archiveAgent(verifierAgent.id);
-        } else {
-          await this.options.agentManager.closeAgent(verifierAgent.id);
-        }
-      } catch {
-        // Ignore cleanup errors for internal loop verifiers.
-      }
-    }
-  }
-
-  private buildWorkerConfig(loop: LoopRecord, iteration: LoopIterationRecord): AgentSessionConfig {
-    return {
-      provider: loop.workerProvider ?? loop.provider,
-      cwd: loop.cwd,
-      model: loop.workerModel ?? loop.model ?? undefined,
-      title: buildWorkerTitle(loop, iteration.index),
-      internal: true,
-    };
-  }
-
-  private buildVerifierConfig(loop: LoopRecord, iteration: LoopIterationRecord): AgentSessionConfig {
-    return {
-      provider: loop.verifierProvider ?? loop.provider,
-      cwd: loop.cwd,
-      model: loop.verifierModel ?? loop.model ?? undefined,
-      title: buildVerifierTitle(loop, iteration.index),
-      internal: true,
-    };
-  }
-
-  private resolveFinalText(timeline: AgentTimelineItem[], finalText: string): string {
-    if (finalText.trim()) {
-      return finalText;
-    }
-    for (let index = timeline.length - 1; index >= 0; index -= 1) {
-      const item = timeline[index];
-      if (item?.type === "assistant_message" && item.text.trim()) {
-        return item.text;
-      }
-    }
-    return "";
-  }
-
-  private toPrompt(text: string): AgentPromptInput {
-    return text;
-  }
-
-  private finishLoop(loop: LoopRecord, status: Exclude<LoopStatus, "running">, message: string): void {
-    loop.status = status;
-    loop.completedAt = nowIso();
-    loop.updatedAt = loop.completedAt;
-    loop.activeIteration = null;
-    loop.activeWorkerAgentId = null;
-    loop.activeVerifierAgentId = null;
-    this.appendLog(loop, {
-      iteration: null,
-      source: "loop",
-      level: status === "succeeded" ? "info" : "error",
-      text: message,
-    });
-  }
-
-  private appendLog(
-    loop: LoopRecord,
-    entry: Omit<LoopLogEntry, "seq" | "timestamp">,
-  ): void {
-    loop.logs.push({
-      seq: loop.nextLogSeq,
-      timestamp: nowIso(),
-      ...entry,
-    });
-    loop.nextLogSeq += 1;
-    loop.updatedAt = nowIso();
-  }
-
-  private requireLoop(idOrPrefix: string): LoopRecord {
-    const trimmed = idOrPrefix.trim();
-    if (!trimmed) {
-      throw new Error("Loop id is required");
-    }
-    const exact = this.loops.get(trimmed);
-    if (exact) {
-      return exact;
-    }
-    const matches = Array.from(this.loops.values()).filter((record) => record.id.startsWith(trimmed));
-    if (matches.length === 1) {
-      return matches[0]!;
-    }
-    if (matches.length > 1) {
-      throw new Error(`Loop id prefix is ambiguous: ${trimmed}`);
-    }
-    throw new Error(`Loop not found: ${trimmed}`);
-  }
-
-  private async persist(): Promise<void> {
-    const nextPersist = this.persistQueue.then(async () => {
-      await fs.mkdir(path.dirname(this.storePath), { recursive: true });
-      const records = Array.from(this.loops.values()).sort((left, right) =>
-        left.createdAt.localeCompare(right.createdAt),
-      );
-      await fs.writeFile(this.storePath, JSON.stringify(records, null, 2), "utf8");
-    });
-    this.persistQueue = nextPersist.catch(() => {});
-    await nextPersist;
-  }
-}

packages/server/src/server/loop/rpc-schemas.ts

@@ -1,191 +0,0 @@
-import { z } from "zod";
-import { AgentProviderSchema } from "../agent/provider-manifest.js";
-
-export const LoopLogEntrySchema = z.object({
-  seq: z.number().int().positive(),
-  timestamp: z.string(),
-  iteration: z.number().int().positive().nullable(),
-  source: z.enum(["loop", "worker", "verifier", "verify-check"]),
-  level: z.enum(["info", "error"]),
-  text: z.string(),
-});
-
-export const LoopVerifyCheckResultSchema = z.object({
-  command: z.string(),
-  exitCode: z.number().int(),
-  passed: z.boolean(),
-  stdout: z.string(),
-  stderr: z.string(),
-  startedAt: z.string(),
-  completedAt: z.string(),
-});
-
-export const LoopVerifyPromptResultSchema = z.object({
-  passed: z.boolean(),
-  reason: z.string(),
-  verifierAgentId: z.string().nullable(),
-  startedAt: z.string(),
-  completedAt: z.string(),
-});
-
-export const LoopIterationRecordSchema = z.object({
-  index: z.number().int().positive(),
-  workerAgentId: z.string().nullable(),
-  workerStartedAt: z.string(),
-  workerCompletedAt: z.string().nullable(),
-  verifierAgentId: z.string().nullable(),
-  status: z.enum(["running", "succeeded", "failed", "stopped"]),
-  workerOutcome: z.enum(["completed", "failed", "canceled"]).nullable(),
-  failureReason: z.string().nullable(),
-  verifyChecks: z.array(LoopVerifyCheckResultSchema),
-  verifyPrompt: LoopVerifyPromptResultSchema.nullable(),
-});
-
-export const LoopRecordSchema = z.object({
-  id: z.string(),
-  name: z.string().nullable(),
-  prompt: z.string(),
-  cwd: z.string(),
-  provider: AgentProviderSchema,
-  model: z.string().nullable(),
-  workerProvider: AgentProviderSchema.nullable(),
-  workerModel: z.string().nullable(),
-  verifierProvider: AgentProviderSchema.nullable(),
-  verifierModel: z.string().nullable(),
-  verifyPrompt: z.string().nullable(),
-  verifyChecks: z.array(z.string()),
-  archive: z.boolean(),
-  sleepMs: z.number().int().nonnegative(),
-  maxIterations: z.number().int().positive().nullable(),
-  maxTimeMs: z.number().int().positive().nullable(),
-  status: z.enum(["running", "succeeded", "failed", "stopped"]),
-  createdAt: z.string(),
-  updatedAt: z.string(),
-  startedAt: z.string(),
-  completedAt: z.string().nullable(),
-  stopRequestedAt: z.string().nullable(),
-  iterations: z.array(LoopIterationRecordSchema),
-  logs: z.array(LoopLogEntrySchema),
-  nextLogSeq: z.number().int().positive(),
-  activeIteration: z.number().int().positive().nullable(),
-  activeWorkerAgentId: z.string().nullable(),
-  activeVerifierAgentId: z.string().nullable(),
-});
-
-export const LoopListItemSchema = z.object({
-  id: z.string(),
-  name: z.string().nullable(),
-  status: z.enum(["running", "succeeded", "failed", "stopped"]),
-  cwd: z.string(),
-  createdAt: z.string(),
-  updatedAt: z.string(),
-  activeIteration: z.number().int().positive().nullable(),
-});
-
-export const LoopRunRequestSchema = z.object({
-  type: z.literal("loop/run"),
-  requestId: z.string(),
-  prompt: z.string().trim().min(1),
-  cwd: z.string(),
-  provider: AgentProviderSchema.optional(),
-  model: z.string().trim().min(1).optional(),
-  workerProvider: AgentProviderSchema.optional(),
-  workerModel: z.string().trim().min(1).optional(),
-  verifierProvider: AgentProviderSchema.optional(),
-  verifierModel: z.string().trim().min(1).optional(),
-  verifyPrompt: z.string().trim().min(1).optional(),
-  verifyChecks: z.array(z.string().trim().min(1)).optional(),
-  archive: z.boolean().optional(),
-  name: z.string().trim().min(1).optional(),
-  sleepMs: z.number().int().nonnegative().optional(),
-  maxIterations: z.number().int().positive().optional(),
-  maxTimeMs: z.number().int().positive().optional(),
-});
-
-export const LoopListRequestSchema = z.object({
-  type: z.literal("loop/list"),
-  requestId: z.string(),
-});
-
-export const LoopInspectRequestSchema = z.object({
-  type: z.literal("loop/inspect"),
-  requestId: z.string(),
-  id: z.string().trim().min(1),
-});
-
-export const LoopLogsRequestSchema = z.object({
-  type: z.literal("loop/logs"),
-  requestId: z.string(),
-  id: z.string().trim().min(1),
-  afterSeq: z.number().int().nonnegative().optional(),
-});
-
-export const LoopStopRequestSchema = z.object({
-  type: z.literal("loop/stop"),
-  requestId: z.string(),
-  id: z.string().trim().min(1),
-});
-
-export const LoopRunResponseSchema = z.object({
-  type: z.literal("loop/run/response"),
-  payload: z.object({
-    requestId: z.string(),
-    loop: LoopRecordSchema.nullable(),
-    error: z.string().nullable(),
-  }),
-});
-
-export const LoopListResponseSchema = z.object({
-  type: z.literal("loop/list/response"),
-  payload: z.object({
-    requestId: z.string(),
-    loops: z.array(LoopListItemSchema),
-    error: z.string().nullable(),
-  }),
-});
-
-export const LoopInspectResponseSchema = z.object({
-  type: z.literal("loop/inspect/response"),
-  payload: z.object({
-    requestId: z.string(),
-    loop: LoopRecordSchema.nullable(),
-    error: z.string().nullable(),
-  }),
-});
-
-export const LoopLogsResponseSchema = z.object({
-  type: z.literal("loop/logs/response"),
-  payload: z.object({
-    requestId: z.string(),
-    loop: LoopRecordSchema.nullable(),
-    entries: z.array(LoopLogEntrySchema),
-    nextCursor: z.number().int().nonnegative(),
-    error: z.string().nullable(),
-  }),
-});
-
-export const LoopStopResponseSchema = z.object({
-  type: z.literal("loop/stop/response"),
-  payload: z.object({
-    requestId: z.string(),
-    loop: LoopRecordSchema.nullable(),
-    error: z.string().nullable(),
-  }),
-});
-
-export type LoopLogEntry = z.infer<typeof LoopLogEntrySchema>;
-export type LoopVerifyCheckResult = z.infer<typeof LoopVerifyCheckResultSchema>;
-export type LoopVerifyPromptResult = z.infer<typeof LoopVerifyPromptResultSchema>;
-export type LoopIterationRecord = z.infer<typeof LoopIterationRecordSchema>;
-export type LoopRecord = z.infer<typeof LoopRecordSchema>;
-export type LoopListItem = z.infer<typeof LoopListItemSchema>;
-export type LoopRunRequest = z.infer<typeof LoopRunRequestSchema>;
-export type LoopListRequest = z.infer<typeof LoopListRequestSchema>;
-export type LoopInspectRequest = z.infer<typeof LoopInspectRequestSchema>;
-export type LoopLogsRequest = z.infer<typeof LoopLogsRequestSchema>;
-export type LoopStopRequest = z.infer<typeof LoopStopRequestSchema>;
-export type LoopRunResponse = z.infer<typeof LoopRunResponseSchema>;
-export type LoopListResponse = z.infer<typeof LoopListResponseSchema>;
-export type LoopInspectResponse = z.infer<typeof LoopInspectResponseSchema>;
-export type LoopLogsResponse = z.infer<typeof LoopLogsResponseSchema>;
-export type LoopStopResponse = z.infer<typeof LoopStopResponseSchema>;

packages/server/src/server/schedule/cron.test.ts

@@ -1,28 +0,0 @@
-import { describe, expect, test } from "vitest";
-import { computeNextRunAt, validateScheduleCadence } from "./cron.js";
-
-describe("schedule cron cadence", () => {
-  test("computes the next every cadence from the provided timestamp", () => {
-    const next = computeNextRunAt(
-      { type: "every", everyMs: 5 * 60_000 },
-      new Date("2026-01-01T00:00:00.000Z"),
-    );
-
-    expect(next.toISOString()).toBe("2026-01-01T00:05:00.000Z");
-  });
-
-  test("computes the next cron minute match in UTC", () => {
-    const next = computeNextRunAt(
-      { type: "cron", expression: "15 9 * * 1-5" },
-      new Date("2026-01-05T09:14:30.000Z"),
-    );
-
-    expect(next.toISOString()).toBe("2026-01-05T09:15:00.000Z");
-  });
-
-  test("rejects invalid cron expressions", () => {
-    expect(() =>
-      validateScheduleCadence({ type: "cron", expression: "not-a-valid-cron" }),
-    ).toThrow("Cron expressions must have 5 fields");
-  });
-});

packages/server/src/server/schedule/cron.ts

@@ -1,150 +0,0 @@
-import type { ScheduleCadence } from "./types.js";
-
-interface CronFieldMatcher {
-  matches(value: number): boolean;
-}
-
-function buildValueSet(values: Iterable<number>): Set<number> {
-  return new Set(values);
-}
-
-function createRange(start: number, end: number, step: number): number[] {
-  const values: number[] = [];
-  for (let value = start; value <= end; value += step) {
-    values.push(value);
-  }
-  return values;
-}
-
-function parseField(
-  source: string,
-  bounds: { min: number; max: number; name: string },
-): CronFieldMatcher {
-  const trimmed = source.trim();
-  if (!trimmed) {
-    throw new Error(`Invalid cron ${bounds.name} field`);
-  }
-
-  const values = new Set<number>();
-  for (const rawPart of trimmed.split(",")) {
-    const part = rawPart.trim();
-    if (!part) {
-      throw new Error(`Invalid cron ${bounds.name} field`);
-    }
-
-    const [base, stepSource] = part.split("/");
-    const step =
-      stepSource === undefined ? 1 : Number.parseInt(stepSource, 10);
-    if (!Number.isInteger(step) || step <= 0) {
-      throw new Error(`Invalid cron ${bounds.name} step`);
-    }
-
-    if (base === "*") {
-      for (const value of createRange(bounds.min, bounds.max, step)) {
-        values.add(value);
-      }
-      continue;
-    }
-
-    const rangeMatch = base.match(/^(\d+)-(\d+)$/);
-    if (rangeMatch) {
-      const start = Number.parseInt(rangeMatch[1], 10);
-      const end = Number.parseInt(rangeMatch[2], 10);
-      if (start > end || start < bounds.min || end > bounds.max) {
-        throw new Error(`Invalid cron ${bounds.name} range`);
-      }
-      for (const value of createRange(start, end, step)) {
-        values.add(value);
-      }
-      continue;
-    }
-
-    const value = Number.parseInt(base, 10);
-    if (!Number.isInteger(value) || value < bounds.min || value > bounds.max) {
-      throw new Error(`Invalid cron ${bounds.name} value`);
-    }
-    values.add(value);
-  }
-
-  const allowed = buildValueSet(values);
-  return {
-    matches(value: number): boolean {
-      return allowed.has(value);
-    },
-  };
-}
-
-interface ParsedCronExpression {
-  minute: CronFieldMatcher;
-  hour: CronFieldMatcher;
-  dayOfMonth: CronFieldMatcher;
-  month: CronFieldMatcher;
-  dayOfWeek: CronFieldMatcher;
-}
-
-function parseCronExpression(expression: string): ParsedCronExpression {
-  const parts = expression.trim().split(/\s+/);
-  if (parts.length !== 5) {
-    throw new Error("Cron expressions must have 5 fields");
-  }
-
-  return {
-    minute: parseField(parts[0], { min: 0, max: 59, name: "minute" }),
-    hour: parseField(parts[1], { min: 0, max: 23, name: "hour" }),
-    dayOfMonth: parseField(parts[2], { min: 1, max: 31, name: "day-of-month" }),
-    month: parseField(parts[3], { min: 1, max: 12, name: "month" }),
-    dayOfWeek: parseField(parts[4], { min: 0, max: 6, name: "day-of-week" }),
-  };
-}
-
-function startOfNextMinute(date: Date): Date {
-  return new Date(
-    Date.UTC(
-      date.getUTCFullYear(),
-      date.getUTCMonth(),
-      date.getUTCDate(),
-      date.getUTCHours(),
-      date.getUTCMinutes() + 1,
-      0,
-      0,
-    ),
-  );
-}
-
-export function validateScheduleCadence(cadence: ScheduleCadence): void {
-  if (cadence.type === "cron") {
-    parseCronExpression(cadence.expression);
-  }
-}
-
-export function computeNextRunAt(cadence: ScheduleCadence, after: Date): Date {
-  if (cadence.type === "every") {
-    return new Date(after.getTime() + cadence.everyMs);
-  }
-
-  const cron = parseCronExpression(cadence.expression);
-  const limit = 366 * 24 * 60;
-  let cursor = startOfNextMinute(after);
-
-  for (let index = 0; index < limit; index += 1) {
-    const minute = cursor.getUTCMinutes();
-    const hour = cursor.getUTCHours();
-    const dayOfMonth = cursor.getUTCDate();
-    const month = cursor.getUTCMonth() + 1;
-    const dayOfWeek = cursor.getUTCDay();
-
-    if (
-      cron.minute.matches(minute) &&
-      cron.hour.matches(hour) &&
-      cron.dayOfMonth.matches(dayOfMonth) &&
-      cron.month.matches(month) &&
-      cron.dayOfWeek.matches(dayOfWeek)
-    ) {
-      return cursor;
-    }
-
-    cursor = new Date(cursor.getTime() + 60_000);
-  }
-
-  throw new Error(`Unable to compute next run time for cron expression: ${cadence.expression}`);
-}

packages/server/src/server/schedule/rpc-schemas.ts

@@ -1,132 +0,0 @@
-import { z } from "zod";
-import {
-  ScheduleCadenceSchema,
-  ScheduleRunSchema,
-  ScheduleSummarySchema,
-  StoredScheduleSchema,
-  ScheduleTargetSchema,
-} from "./types.js";
-
-const ScheduleCreateTargetSchema = z.discriminatedUnion("type", [
-  z.object({
-    type: z.literal("self"),
-    agentId: z.string().uuid(),
-  }),
-  z.object({
-    type: z.literal("agent"),
-    agentId: z.string().uuid(),
-  }),
-  z.object({
-    type: z.literal("new-agent"),
-    config: ScheduleTargetSchema.options[1].shape.config,
-  }),
-]);
-
-export const ScheduleCreateRequestSchema = z.object({
-  type: z.literal("schedule/create"),
-  requestId: z.string(),
-  prompt: z.string().min(1),
-  name: z.string().optional(),
-  cadence: ScheduleCadenceSchema,
-  target: ScheduleCreateTargetSchema,
-  maxRuns: z.number().int().positive().optional(),
-  expiresAt: z.string().optional(),
-});
-
-export const ScheduleListRequestSchema = z.object({
-  type: z.literal("schedule/list"),
-  requestId: z.string(),
-});
-
-export const ScheduleInspectRequestSchema = z.object({
-  type: z.literal("schedule/inspect"),
-  requestId: z.string(),
-  scheduleId: z.string(),
-});
-
-export const ScheduleLogsRequestSchema = z.object({
-  type: z.literal("schedule/logs"),
-  requestId: z.string(),
-  scheduleId: z.string(),
-});
-
-export const SchedulePauseRequestSchema = z.object({
-  type: z.literal("schedule/pause"),
-  requestId: z.string(),
-  scheduleId: z.string(),
-});
-
-export const ScheduleResumeRequestSchema = z.object({
-  type: z.literal("schedule/resume"),
-  requestId: z.string(),
-  scheduleId: z.string(),
-});
-
-export const ScheduleDeleteRequestSchema = z.object({
-  type: z.literal("schedule/delete"),
-  requestId: z.string(),
-  scheduleId: z.string(),
-});
-
-export const ScheduleCreateResponseSchema = z.object({
-  type: z.literal("schedule/create/response"),
-  payload: z.object({
-    requestId: z.string(),
-    schedule: ScheduleSummarySchema.nullable(),
-    error: z.string().nullable(),
-  }),
-});
-
-export const ScheduleListResponseSchema = z.object({
-  type: z.literal("schedule/list/response"),
-  payload: z.object({
-    requestId: z.string(),
-    schedules: z.array(ScheduleSummarySchema),
-    error: z.string().nullable(),
-  }),
-});
-
-export const ScheduleInspectResponseSchema = z.object({
-  type: z.literal("schedule/inspect/response"),
-  payload: z.object({
-    requestId: z.string(),
-    schedule: StoredScheduleSchema.nullable(),
-    error: z.string().nullable(),
-  }),
-});
-
-export const ScheduleLogsResponseSchema = z.object({
-  type: z.literal("schedule/logs/response"),
-  payload: z.object({
-    requestId: z.string(),
-    runs: z.array(ScheduleRunSchema),
-    error: z.string().nullable(),
-  }),
-});
-
-export const SchedulePauseResponseSchema = z.object({
-  type: z.literal("schedule/pause/response"),
-  payload: z.object({
-    requestId: z.string(),
-    schedule: ScheduleSummarySchema.nullable(),
-    error: z.string().nullable(),
-  }),
-});
-
-export const ScheduleResumeResponseSchema = z.object({
-  type: z.literal("schedule/resume/response"),
-  payload: z.object({
-    requestId: z.string(),
-    schedule: ScheduleSummarySchema.nullable(),
-    error: z.string().nullable(),
-  }),
-});
-
-export const ScheduleDeleteResponseSchema = z.object({
-  type: z.literal("schedule/delete/response"),
-  payload: z.object({
-    requestId: z.string(),
-    scheduleId: z.string(),
-    error: z.string().nullable(),
-  }),
-});

packages/server/src/server/schedule/service.test.ts

@@ -1,229 +0,0 @@
-import { mkdir, mkdtemp, rm } from "node:fs/promises";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-import { afterEach, beforeEach, describe, expect, test } from "vitest";
-import { AgentManager } from "../agent/agent-manager.js";
-import { AgentStorage } from "../agent/agent-storage.js";
-import { createTestAgentClients } from "../test-utils/fake-agent-client.js";
-import { createTestLogger } from "../../test-utils/test-logger.js";
-import { ScheduleService } from "./service.js";
-
-describe("ScheduleService", () => {
-  let tempDir: string;
-  let agentStorage: AgentStorage;
-  let now: Date;
-
-  beforeEach(async () => {
-    tempDir = await mkdtemp(join(tmpdir(), "schedule-service-test-"));
-    await mkdir(join(tempDir, "agents"), { recursive: true });
-    agentStorage = new AgentStorage(join(tempDir, "agents"), createTestLogger());
-    await agentStorage.initialize();
-    now = new Date("2026-01-01T00:00:00.000Z");
-  });
-
-  afterEach(async () => {
-    await rm(tempDir, { recursive: true, force: true });
-  });
-
-  test("ticks due schedules and records run history on disk", async () => {
-    const service = new ScheduleService({
-      paseoHome: tempDir,
-      logger: createTestLogger(),
-      agentManager: new AgentManager({ logger: createTestLogger() }),
-      agentStorage,
-      now: () => now,
-      runner: async (schedule) => ({
-        agentId: "00000000-0000-0000-0000-000000000001",
-        output: `ran:${schedule.prompt}`,
-      }),
-    });
-
-    const created = await service.create({
-      prompt: "Review new PRs",
-      cadence: { type: "every", everyMs: 60_000 },
-      target: {
-        type: "new-agent",
-        config: {
-          provider: "claude",
-          cwd: tempDir,
-        },
-      },
-    });
-
-    now = new Date("2026-01-01T00:01:00.000Z");
-    await service.tick();
-
-    const inspected = await service.inspect(created.id);
-    expect(inspected.runs).toHaveLength(1);
-    expect(inspected.runs[0]).toMatchObject({
-      status: "succeeded",
-      agentId: "00000000-0000-0000-0000-000000000001",
-      output: "ran:Review new PRs",
-    });
-    expect(inspected.nextRunAt).toBe("2026-01-01T00:02:00.000Z");
-  });
-
-  test("pause and resume update persisted schedule state", async () => {
-    const service = new ScheduleService({
-      paseoHome: tempDir,
-      logger: createTestLogger(),
-      agentManager: new AgentManager({ logger: createTestLogger() }),
-      agentStorage,
-      now: () => now,
-      runner: async () => ({
-        agentId: null,
-        output: "ok",
-      }),
-    });
-
-    const created = await service.create({
-      prompt: "Check status",
-      cadence: { type: "every", everyMs: 60_000 },
-      target: {
-        type: "new-agent",
-        config: {
-          provider: "claude",
-          cwd: tempDir,
-        },
-      },
-    });
-
-    const paused = await service.pause(created.id);
-    expect(paused.status).toBe("paused");
-    expect(paused.nextRunAt).toBeNull();
-
-    now = new Date("2026-01-01T00:03:00.000Z");
-    const resumed = await service.resume(created.id);
-    expect(resumed.status).toBe("active");
-    expect(resumed.nextRunAt).toBe("2026-01-01T00:04:00.000Z");
-  });
-
-  test("completes schedules when max runs is reached", async () => {
-    const service = new ScheduleService({
-      paseoHome: tempDir,
-      logger: createTestLogger(),
-      agentManager: new AgentManager({ logger: createTestLogger() }),
-      agentStorage,
-      now: () => now,
-      runner: async () => ({
-        agentId: null,
-        output: "done",
-      }),
-    });
-
-    const created = await service.create({
-      prompt: "One shot",
-      cadence: { type: "every", everyMs: 60_000 },
-      target: {
-        type: "new-agent",
-        config: {
-          provider: "claude",
-          cwd: tempDir,
-        },
-      },
-      maxRuns: 1,
-    });
-
-    now = new Date("2026-01-01T00:01:00.000Z");
-    await service.tick();
-
-    const inspected = await service.inspect(created.id);
-    expect(inspected.status).toBe("completed");
-    expect(inspected.nextRunAt).toBeNull();
-  });
-
-  test("executes new-agent schedules through AgentManager with real fake clients", async () => {
-    const manager = new AgentManager({
-      logger: createTestLogger(),
-      clients: createTestAgentClients(),
-      registry: agentStorage,
-    });
-    const service = new ScheduleService({
-      paseoHome: tempDir,
-      logger: createTestLogger(),
-      agentManager: manager,
-      agentStorage,
-      now: () => now,
-    });
-
-    const created = await service.create({
-      prompt: "Respond with exactly hello",
-      cadence: { type: "every", everyMs: 60_000 },
-      target: {
-        type: "new-agent",
-        config: {
-          provider: "claude",
-          cwd: tempDir,
-          approvalPolicy: "never",
-        },
-      },
-      maxRuns: 1,
-    });
-
-    now = new Date("2026-01-01T00:01:00.000Z");
-    await service.tick();
-
-    const inspected = await service.inspect(created.id);
-    expect(inspected.runs).toHaveLength(1);
-    expect(inspected.runs[0]?.status).toBe("succeeded");
-    expect(inspected.runs[0]?.agentId).toMatch(
-      /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/,
-    );
-  });
-
-  test("keeps schedules paused when an in-flight run finishes after pause", async () => {
-    let releaseRun: (() => void) | null = null;
-    const runStarted = new Promise<void>((resolve) => {
-      releaseRun = resolve;
-    });
-    let finishRun: (() => void) | null = null;
-    const runBlocked = new Promise<void>((resolve) => {
-      finishRun = resolve;
-    });
-
-    const service = new ScheduleService({
-      paseoHome: tempDir,
-      logger: createTestLogger(),
-      agentManager: new AgentManager({ logger: createTestLogger() }),
-      agentStorage,
-      now: () => now,
-      runner: async () => {
-        releaseRun?.();
-        await runBlocked;
-        return {
-          agentId: null,
-          output: "finished",
-        };
-      },
-    });
-
-    const created = await service.create({
-      prompt: "Check status",
-      cadence: { type: "every", everyMs: 60_000 },
-      target: {
-        type: "new-agent",
-        config: {
-          provider: "claude",
-          cwd: tempDir,
-        },
-      },
-    });
-
-    now = new Date("2026-01-01T00:01:00.000Z");
-    const tickPromise = service.tick();
-    await runStarted;
-
-    const paused = await service.pause(created.id);
-    expect(paused.status).toBe("paused");
-    expect(paused.nextRunAt).toBeNull();
-
-    finishRun?.();
-    await tickPromise;
-
-    const inspected = await service.inspect(created.id);
-    expect(inspected.status).toBe("paused");
-    expect(inspected.nextRunAt).toBeNull();
-    expect(inspected.runs).toHaveLength(1);
-    expect(inspected.runs[0]?.status).toBe("succeeded");
-  });
-});

packages/server/src/server/schedule/service.ts

@@ -1,472 +0,0 @@
-import { randomUUID } from "node:crypto";
-import { join } from "node:path";
-import type { Logger } from "pino";
-import { AgentManager } from "../agent/agent-manager.js";
-import type { ManagedAgent } from "../agent/agent-manager.js";
-import { AgentStorage } from "../agent/agent-storage.js";
-import type {
-  AgentPromptInput,
-  AgentSessionConfig,
-} from "../agent/agent-sdk-types.js";
-import { curateAgentActivity } from "../agent/activity-curator.js";
-import { buildConfigOverrides, buildSessionConfig, extractTimestamps } from "../persistence-hooks.js";
-import { ScheduleStore } from "./store.js";
-import { computeNextRunAt, validateScheduleCadence } from "./cron.js";
-import type {
-  CreateScheduleInput,
-  ScheduleExecutionResult,
-  ScheduleRun,
-  StoredSchedule,
-} from "./types.js";
-
-const SCHEDULE_TICK_INTERVAL_MS = 1000;
-const pendingAgentInitializations = new Map<string, Promise<ManagedAgent>>();
-
-function trimOptionalName(value: string | null | undefined): string | null {
-  if (typeof value !== "string") {
-    return null;
-  }
-  const trimmed = value.trim();
-  return trimmed.length > 0 ? trimmed : null;
-}
-
-function normalizePrompt(prompt: string): string {
-  const trimmed = prompt.trim();
-  if (!trimmed) {
-    throw new Error("Schedule prompt is required");
-  }
-  return trimmed;
-}
-
-function normalizeMaxRuns(value: number | null | undefined): number | null {
-  if (value == null) {
-    return null;
-  }
-  if (!Number.isInteger(value) || value <= 0) {
-    throw new Error("maxRuns must be a positive integer");
-  }
-  return value;
-}
-
-function countCompletedRuns(schedule: StoredSchedule): number {
-  return schedule.runs.filter((run) => run.status !== "running").length;
-}
-
-function shouldCompleteSchedule(schedule: StoredSchedule, now: Date): boolean {
-  if (schedule.expiresAt && new Date(schedule.expiresAt).getTime() <= now.getTime()) {
-    return true;
-  }
-  if (schedule.maxRuns == null) {
-    return false;
-  }
-  return countCompletedRuns(schedule) >= schedule.maxRuns;
-}
-
-function completeSchedule(schedule: StoredSchedule, now: Date): StoredSchedule {
-  return {
-    ...schedule,
-    status: "completed",
-    nextRunAt: null,
-    pausedAt: null,
-    updatedAt: now.toISOString(),
-  };
-}
-
-function buildRunOutput(params: {
-  output: string | null;
-  timelineText: string;
-  finalText: string;
-}): string | null {
-  if (params.output && params.output.trim().length > 0) {
-    return params.output;
-  }
-  if (params.finalText.trim().length > 0) {
-    return params.finalText.trim();
-  }
-  if (params.timelineText.trim().length > 0) {
-    return params.timelineText.trim();
-  }
-  return null;
-}
-
-function buildAgentPrompt(text: string): AgentPromptInput {
-  return text;
-}
-
-export interface ScheduleServiceOptions {
-  paseoHome: string;
-  logger: Logger;
-  agentManager: AgentManager;
-  agentStorage: AgentStorage;
-  now?: () => Date;
-  runner?: (schedule: StoredSchedule) => Promise<ScheduleExecutionResult>;
-}
-
-export class ScheduleService {
-  private readonly store: ScheduleStore;
-  private readonly logger: Logger;
-  private readonly agentManager: AgentManager;
-  private readonly agentStorage: AgentStorage;
-  private readonly now: () => Date;
-  private readonly runner: (schedule: StoredSchedule) => Promise<ScheduleExecutionResult>;
-  private readonly runningScheduleIds = new Set<string>();
-  private tickTimer: ReturnType<typeof setInterval> | null = null;
-
-  constructor(options: ScheduleServiceOptions) {
-    this.store = new ScheduleStore(join(options.paseoHome, "schedules"));
-    this.logger = options.logger.child({ module: "schedule-service" });
-    this.agentManager = options.agentManager;
-    this.agentStorage = options.agentStorage;
-    this.now = options.now ?? (() => new Date());
-    this.runner = options.runner ?? ((schedule) => this.executeSchedule(schedule));
-  }
-
-  async start(): Promise<void> {
-    await this.recoverInterruptedRuns();
-    if (this.tickTimer) {
-      return;
-    }
-    const timer = setInterval(() => {
-      void this.tick().catch((error) => {
-        this.logger.error({ err: error }, "Failed to process schedule tick");
-      });
-    }, SCHEDULE_TICK_INTERVAL_MS);
-    (timer as unknown as { unref?: () => void }).unref?.();
-    this.tickTimer = timer;
-  }
-
-  async stop(): Promise<void> {
-    if (this.tickTimer) {
-      clearInterval(this.tickTimer);
-      this.tickTimer = null;
-    }
-  }
-
-  async create(input: CreateScheduleInput): Promise<StoredSchedule> {
-    const now = this.now();
-    const prompt = normalizePrompt(input.prompt);
-    validateScheduleCadence(input.cadence);
-    const schedule = await this.store.create({
-      name: trimOptionalName(input.name),
-      prompt,
-      cadence: input.cadence,
-      target: input.target,
-      status: "active",
-      createdAt: now.toISOString(),
-      updatedAt: now.toISOString(),
-      nextRunAt: computeNextRunAt(input.cadence, now).toISOString(),
-      lastRunAt: null,
-      pausedAt: null,
-      expiresAt: input.expiresAt ?? null,
-      maxRuns: normalizeMaxRuns(input.maxRuns),
-      runs: [],
-    });
-    return schedule;
-  }
-
-  async list(): Promise<StoredSchedule[]> {
-    return this.store.list();
-  }
-
-  async inspect(id: string): Promise<StoredSchedule> {
-    const schedule = await this.store.get(id);
-    if (!schedule) {
-      throw new Error(`Schedule not found: ${id}`);
-    }
-    return schedule;
-  }
-
-  async logs(id: string): Promise<ScheduleRun[]> {
-    const schedule = await this.inspect(id);
-    return [...schedule.runs].sort((left, right) => left.startedAt.localeCompare(right.startedAt));
-  }
-
-  async pause(id: string): Promise<StoredSchedule> {
-    const schedule = await this.inspect(id);
-    if (schedule.status === "completed") {
-      throw new Error(`Schedule ${id} is already completed`);
-    }
-    if (schedule.status === "paused") {
-      return schedule;
-    }
-    const now = this.now();
-    const paused = {
-      ...schedule,
-      status: "paused" as const,
-      nextRunAt: null,
-      pausedAt: now.toISOString(),
-      updatedAt: now.toISOString(),
-    };
-    await this.store.put(paused);
-    return paused;
-  }
-
-  async resume(id: string): Promise<StoredSchedule> {
-    const schedule = await this.inspect(id);
-    if (schedule.status === "completed") {
-      throw new Error(`Schedule ${id} is already completed`);
-    }
-    if (schedule.status === "active") {
-      return schedule;
-    }
-    const now = this.now();
-    const resumed = {
-      ...schedule,
-      status: "active" as const,
-      pausedAt: null,
-      nextRunAt: computeNextRunAt(schedule.cadence, now).toISOString(),
-      updatedAt: now.toISOString(),
-    };
-    await this.store.put(resumed);
-    return resumed;
-  }
-
-  async delete(id: string): Promise<void> {
-    await this.store.delete(id);
-  }
-
-  async tick(): Promise<void> {
-    const now = this.now();
-    const schedules = await this.store.list();
-    for (const schedule of schedules) {
-      if (schedule.status !== "active" || !schedule.nextRunAt) {
-        continue;
-      }
-      if (this.runningScheduleIds.has(schedule.id)) {
-        continue;
-      }
-      if (shouldCompleteSchedule(schedule, now)) {
-        await this.store.put(completeSchedule(schedule, now));
-        continue;
-      }
-      if (new Date(schedule.nextRunAt).getTime() > now.getTime()) {
-        continue;
-      }
-      await this.runSchedule(schedule, now);
-    }
-  }
-
-  private async recoverInterruptedRuns(): Promise<void> {
-    const schedules = await this.store.list();
-    const now = this.now();
-    for (const schedule of schedules) {
-      const runningIndex = schedule.runs.findIndex((run) => run.status === "running");
-      if (runningIndex === -1) {
-        continue;
-      }
-      const runs = [...schedule.runs];
-      runs[runningIndex] = {
-        ...runs[runningIndex],
-        status: "failed",
-        endedAt: now.toISOString(),
-        error: "Daemon restarted before the scheduled run completed",
-      };
-      const nextSchedule = {
-        ...schedule,
-        runs,
-        updatedAt: now.toISOString(),
-      };
-      await this.store.put(nextSchedule);
-    }
-  }
-
-  private async runSchedule(schedule: StoredSchedule, now: Date): Promise<void> {
-    this.runningScheduleIds.add(schedule.id);
-    const runId = randomUUID();
-    const runningRun: ScheduleRun = {
-      id: runId,
-      scheduledFor: schedule.nextRunAt ?? now.toISOString(),
-      startedAt: now.toISOString(),
-      endedAt: null,
-      status: "running",
-      agentId: null,
-      output: null,
-      error: null,
-    };
-    const scheduleWithRun = {
-      ...schedule,
-      updatedAt: now.toISOString(),
-      runs: [...schedule.runs, runningRun],
-    };
-    await this.store.put(scheduleWithRun);
-
-    try {
-      const result = await this.runner(scheduleWithRun);
-      await this.finishRun({
-        scheduleId: schedule.id,
-        runId,
-        status: "succeeded",
-        agentId: result.agentId,
-        output: result.output,
-        error: null,
-      });
-    } catch (error) {
-      await this.finishRun({
-        scheduleId: schedule.id,
-        runId,
-        status: "failed",
-        agentId: null,
-        output: null,
-        error: error instanceof Error ? error.message : String(error),
-      });
-    } finally {
-      this.runningScheduleIds.delete(schedule.id);
-    }
-  }
-
-  private async finishRun(params: {
-    scheduleId: string;
-    runId: string;
-    status: "succeeded" | "failed";
-    agentId: string | null;
-    output: string | null;
-    error: string | null;
-  }): Promise<void> {
-    const schedule = await this.inspect(params.scheduleId);
-    const now = this.now();
-    const completedRuns = schedule.runs.map((run) =>
-      run.id === params.runId
-        ? {
-            ...run,
-            status: params.status,
-            endedAt: now.toISOString(),
-            agentId: params.agentId,
-            output: params.output,
-            error: params.error,
-          }
-        : run,
-    );
-    let updated: StoredSchedule = {
-      ...schedule,
-      runs: completedRuns,
-      lastRunAt: now.toISOString(),
-      updatedAt: now.toISOString(),
-    };
-
-    if (shouldCompleteSchedule(updated, now)) {
-      updated = completeSchedule(updated, now);
-    } else if (updated.status === "paused") {
-      updated = {
-        ...updated,
-        nextRunAt: null,
-      };
-    } else {
-      const after = new Date(schedule.nextRunAt ?? now.toISOString());
-      let nextRunAt = computeNextRunAt(updated.cadence, after);
-      while (nextRunAt.getTime() <= now.getTime()) {
-        nextRunAt = computeNextRunAt(updated.cadence, nextRunAt);
-      }
-      updated = {
-        ...updated,
-        nextRunAt: nextRunAt.toISOString(),
-      };
-    }
-
-    await this.store.put(updated);
-  }
-
-  private async executeSchedule(schedule: StoredSchedule): Promise<ScheduleExecutionResult> {
-    if (schedule.target.type === "agent") {
-      const agent = await this.ensureAgentLoaded(schedule.target.agentId);
-      if (this.agentManager.hasInFlightRun(agent.id)) {
-        throw new Error(`Agent ${agent.id} already has an active run`);
-      }
-      this.agentManager.recordUserMessage(agent.id, schedule.prompt, { emitState: false });
-      const result = await this.agentManager.runAgent(agent.id, buildAgentPrompt(schedule.prompt));
-      const timelineText = curateAgentActivity(result.timeline);
-      return {
-        agentId: agent.id,
-        output: buildRunOutput({
-          output: null,
-          timelineText,
-          finalText: result.finalText,
-        }),
-      };
-    }
-
-    const config: AgentSessionConfig = {
-      provider: schedule.target.config.provider,
-      cwd: schedule.target.config.cwd,
-      modeId: schedule.target.config.modeId,
-      model: schedule.target.config.model,
-      thinkingOptionId: schedule.target.config.thinkingOptionId,
-      title: schedule.target.config.title,
-      approvalPolicy: schedule.target.config.approvalPolicy,
-      sandboxMode: schedule.target.config.sandboxMode,
-      networkAccess: schedule.target.config.networkAccess,
-      webSearch: schedule.target.config.webSearch,
-      extra: schedule.target.config.extra,
-      systemPrompt: schedule.target.config.systemPrompt,
-      mcpServers: schedule.target.config.mcpServers as AgentSessionConfig["mcpServers"],
-    };
-    const labels = {
-      "paseo.schedule-id": schedule.id,
-      "paseo.schedule-run": randomUUID(),
-    };
-    const agent = await this.agentManager.createAgent(config, undefined, { labels });
-    this.agentManager.recordUserMessage(agent.id, schedule.prompt, { emitState: false });
-    const result = await this.agentManager.runAgent(agent.id, buildAgentPrompt(schedule.prompt));
-    const timelineText = curateAgentActivity(result.timeline);
-    return {
-      agentId: agent.id,
-      output: buildRunOutput({
-        output: null,
-        timelineText,
-        finalText: result.finalText,
-      }),
-    };
-  }
-
-  private async ensureAgentLoaded(agentId: string): Promise<ManagedAgent> {
-    const existing = this.agentManager.getAgent(agentId);
-    if (existing) {
-      return existing;
-    }
-
-    const inflight = pendingAgentInitializations.get(agentId);
-    if (inflight) {
-      return inflight;
-    }
-
-    const initPromise = (async () => {
-      const record = await this.agentStorage.get(agentId);
-      if (!record) {
-        throw new Error(`Agent not found: ${agentId}`);
-      }
-      if (record.archivedAt) {
-        throw new Error(`Agent ${agentId} is archived`);
-      }
-
-      let snapshot: ManagedAgent;
-      if (record.persistence?.provider && record.persistence?.sessionId) {
-        snapshot = await this.agentManager.resumeAgentFromPersistence(
-          {
-            provider: record.persistence.provider as AgentSessionConfig["provider"],
-            sessionId: record.persistence.sessionId,
-            nativeHandle: record.persistence.nativeHandle,
-            metadata: record.persistence.metadata,
-          },
-          buildConfigOverrides(record),
-          agentId,
-          extractTimestamps(record),
-        );
-      } else {
-        snapshot = await this.agentManager.createAgent(buildSessionConfig(record), agentId, {
-          labels: record.labels,
-        });
-      }
-
-      await this.agentManager.hydrateTimelineFromProvider(agentId);
-      return this.agentManager.getAgent(agentId) ?? snapshot;
-    })();
-
-    pendingAgentInitializations.set(agentId, initPromise);
-    try {
-      return await initPromise;
-    } finally {
-      if (pendingAgentInitializations.get(agentId) === initPromise) {
-        pendingAgentInitializations.delete(agentId);
-      }
-    }
-  }
-}

packages/server/src/server/schedule/store.test.ts

@@ -1,78 +0,0 @@
-import { mkdtemp, rm } from "node:fs/promises";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-import { afterEach, beforeEach, describe, expect, test } from "vitest";
-import { ScheduleStore } from "./store.js";
-
-describe("ScheduleStore", () => {
-  let tempDir: string;
-  let store: ScheduleStore;
-
-  beforeEach(async () => {
-    tempDir = await mkdtemp(join(tmpdir(), "schedule-store-test-"));
-    store = new ScheduleStore(tempDir);
-  });
-
-  afterEach(async () => {
-    await rm(tempDir, { recursive: true, force: true });
-  });
-
-  test("creates and reloads schedules from disk", async () => {
-    const created = await store.create({
-      name: "Morning summary",
-      prompt: "Summarize new commits",
-      cadence: { type: "every", everyMs: 60_000 },
-      target: {
-        type: "new-agent",
-        config: {
-          provider: "claude",
-          cwd: tempDir,
-        },
-      },
-      status: "active",
-      createdAt: "2026-01-01T00:00:00.000Z",
-      updatedAt: "2026-01-01T00:00:00.000Z",
-      nextRunAt: "2026-01-01T00:01:00.000Z",
-      lastRunAt: null,
-      pausedAt: null,
-      expiresAt: null,
-      maxRuns: null,
-      runs: [],
-    });
-
-    const reloaded = new ScheduleStore(tempDir);
-    const listed = await reloaded.list();
-
-    expect(created.id).toHaveLength(8);
-    expect(listed).toEqual([created]);
-  });
-
-  test("deletes schedules from disk", async () => {
-    const created = await store.create({
-      name: null,
-      prompt: "Check status",
-      cadence: { type: "every", everyMs: 30_000 },
-      target: {
-        type: "new-agent",
-        config: {
-          provider: "claude",
-          cwd: tempDir,
-        },
-      },
-      status: "active",
-      createdAt: "2026-01-01T00:00:00.000Z",
-      updatedAt: "2026-01-01T00:00:00.000Z",
-      nextRunAt: "2026-01-01T00:00:30.000Z",
-      lastRunAt: null,
-      pausedAt: null,
-      expiresAt: null,
-      maxRuns: null,
-      runs: [],
-    });
-
-    await store.delete(created.id);
-
-    expect(await store.get(created.id)).toBeNull();
-    expect(await store.list()).toEqual([]);
-  });
-});