feat(website): redeploy on new GitHub releases

The website fetches the latest release version at build time, so it
needs to redeploy when a new release is published to pick up updated
download links.

.github/workflows/deploy-website.yml

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

CHANGELOG.md

@@ -1,5 +1,15 @@
 # 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,20 +26,32 @@ Run agents in parallel on your own machines. Ship from your phone or your desk.
 
 ## Getting Started
 
-### Desktop app
+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.
 
-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.
+### Prerequisites
 
-### Headless / server mode
+You need at least one agent CLI installed and configured with your credentials:
 
-Run the daemon on any machine:
+- [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:
 
 ```bash
 npm install -g @getpaseo/cli
 paseo
 ```
 
-Then connect from any client — desktop, web, mobile, or CLI. See [paseo.sh/download](https://paseo.sh/download) for all options.
+This shows a QR code in the terminal. Connect from any client. This path is useful for servers and remote machines.
 
 For full setup and configuration, see:
 - [Docs](https://paseo.sh/docs)

docs/ARCHITECTURE.md

@@ -31,6 +31,14 @@ 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-jBl1E7cwEf5XKXFQip/ZlEa/zNQoz0Hq5t0hqjp8Qe4=";
+  npmDepsHash = "sha256-ebbF7pug19PBgJQahUCTlvhcLS/LF8Nv1UIIG31LRmQ=";
 
   # 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,6 +25126,15 @@
         "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",
@@ -35309,6 +35318,7 @@
         "@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",
@@ -35351,6 +35361,15 @@
         "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",
@@ -35703,6 +35722,7 @@
         "@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, ActivityIndicator, Text } from "react-native";
+import { View, Text } from "react-native";
 import { UnistylesRuntime, useUnistyles } from "react-native-unistyles";
 import { darkTheme } from "@/styles/theme";
 import { QueryClientProvider } from "@tanstack/react-query";
@@ -26,12 +26,13 @@ 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,
@@ -68,6 +69,7 @@ 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,
@@ -79,7 +81,18 @@ import {
 import { syncNavigationActiveWorkspace } from "@/stores/navigation-active-workspace-store";
 
 polyfillCrypto();
-const HostRuntimeBootstrapContext = createContext(false);
+
+export type HostRuntimeBootstrapState = {
+  phase: "starting-daemon" | "connecting" | "online" | "error";
+  error: string | null;
+  retry: () => void;
+};
+
+const HostRuntimeBootstrapContext = createContext<HostRuntimeBootstrapState>({
+  phase: "starting-daemon",
+  error: null,
+  retry: () => {},
+});
 
 function PushNotificationRouter() {
   const router = useRouter();
@@ -207,49 +220,99 @@ function HostSessionManager() {
 }
 
 function HostRuntimeBootstrapProvider({ children }: { children: ReactNode }) {
-  const [ready, setReady] = useState(false);
+  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);
+  }, []);
 
   useEffect(() => {
     let cancelled = false;
+    const shouldManageDesktop = shouldUseDesktopDaemon();
     const store = getHostRuntimeStore();
 
     const init = async () => {
       const settings = await loadSettingsFromStorage();
-      const isDesktopManaged = shouldUseDesktopDaemon() && settings.manageBuiltInDaemon;
+      const isDesktopManaged = shouldManageDesktop && settings.manageBuiltInDaemon;
       await store.loadFromStorage();
       if (isDesktopManaged) {
-        await store.bootstrap({ manageBuiltInDaemon: true });
+        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);
+        }
       } else {
         void store.bootstrap({ manageBuiltInDaemon: settings.manageBuiltInDaemon });
+        if (!cancelled) {
+          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);
-        }
-      });
+    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);
+    });
 
     return () => {
       cancelled = true;
     };
-  }, []);
+  }, [retryToken]);
+
+  const state = useMemo<HostRuntimeBootstrapState>(
+    () => ({
+      phase,
+      error,
+      retry,
+    }),
+    [error, phase, retry],
+  );
 
   return (
-    <HostRuntimeBootstrapContext.Provider value={ready}>
+    <HostRuntimeBootstrapContext.Provider value={state}>
       {children}
     </HostRuntimeBootstrapContext.Provider>
   );
 }
 
-function useStoreReady(): boolean {
+export function useStoreReady(): boolean {
+  return useContext(HostRuntimeBootstrapContext).phase === "online";
+}
+
+export function useHostRuntimeBootstrapState(): HostRuntimeBootstrapState {
   return useContext(HostRuntimeBootstrapContext);
 }
 
@@ -410,26 +473,30 @@ function MobileGestureWrapper({
 
 function ProvidersWrapper({ children }: { children: ReactNode }) {
   const { settings, isLoading: settingsLoading } = useAppSettings();
-  const storeReady = useStoreReady();
   const { upsertConnectionFromOfferUrl } = useHostMutations();
-  const isLoading = settingsLoading || !storeReady;
+  const systemColorScheme = useColorScheme();
+  const resolvedTheme = settings.theme === "auto" ? (systemColorScheme ?? "light") : settings.theme;
 
   // Apply theme setting on mount and when it changes
   useEffect(() => {
-    if (isLoading) return;
+    if (settingsLoading) return;
     if (settings.theme === "auto") {
       UnistylesRuntime.setAdaptiveThemes(true);
     } else {
       UnistylesRuntime.setAdaptiveThemes(false);
       UnistylesRuntime.setTheme(settings.theme);
     }
-  }, [isLoading, settings.theme]);
+  }, [settingsLoading, settings.theme]);
 
-  if (isLoading) {
-    const isDesktopManaged =
-      !settingsLoading && shouldUseDesktopDaemon() && settings.manageBuiltInDaemon;
-    return isDesktopManaged ? <StartupSplashScreen /> : <LoadingView />;
-  }
+  useEffect(() => {
+    if (settingsLoading || Platform.OS !== "web") {
+      return;
+    }
+
+    void setDesktopTitleBarTheme(resolvedTheme).catch((error) => {
+      console.warn("[DesktopWindow] Failed to update title bar theme", error);
+    });
+  }, [settingsLoading, resolvedTheme]);
 
   return (
     <VoiceProvider>
@@ -532,6 +599,38 @@ 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();
 
@@ -552,57 +651,6 @@ 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 }}>
@@ -619,28 +667,7 @@ export default function RootLayout() {
                       <HorizontalScrollProvider>
                         <ToastProvider>
                           <AppWithSidebar>
-                            <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>
+                            <RootStack />
                           </AppWithSidebar>
                         </ToastProvider>
                       </HorizontalScrollProvider>

packages/app/src/app/index.tsx

@@ -1,18 +1,65 @@
-import { useEffect } from "react";
+import { useEffect, useSyncExternalStore } 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]);
 
-  return null;
+    const targetRoute = anyOnlineServerId
+      ? buildHostRootRoute(anyOnlineServerId)
+      : WELCOME_ROUTE;
+    router.replace(targetRoute as any);
+  }, [anyOnlineServerId, pathname, router, storeReady]);
+
+  return <StartupSplashScreen bootstrapState={bootstrapState} />;
 }

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

@@ -8,6 +8,7 @@ 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,
@@ -609,6 +610,7 @@ 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;
@@ -709,6 +711,17 @@ 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);
         });
@@ -719,6 +732,23 @@ 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,6 +10,7 @@ import { getShortcutOs } from "@/utils/shortcut-platform";
 interface MenuHeaderProps {
   title?: string;
   rightContent?: ReactNode;
+  borderless?: boolean;
 }
 
 interface SidebarMenuToggleProps {
@@ -75,7 +76,7 @@ export function SidebarMenuToggle({
   );
 }
 
-export function MenuHeader({ title, rightContent }: MenuHeaderProps) {
+export function MenuHeader({ title, rightContent, borderless }: MenuHeaderProps) {
   return (
     <ScreenHeader
       left={
@@ -90,6 +91,7 @@ export function MenuHeader({ title, rightContent }: MenuHeaderProps) {
       }
       right={rightContent}
       leftStyle={styles.left}
+      borderless={borderless}
     />
   );
 }

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

@@ -15,13 +15,14 @@ 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 }: ScreenHeaderProps) {
+export function ScreenHeader({ left, right, leftStyle, rightStyle, borderless }: ScreenHeaderProps) {
   const { theme } = useUnistyles();
   const insets = useSafeAreaInsets();
   const isMobile = UnistylesRuntime.breakpoint === "xs" || UnistylesRuntime.breakpoint === "sm";
@@ -47,6 +48,7 @@ export function ScreenHeader({ left, right, leftStyle, rightStyle }: ScreenHeade
               paddingLeft: baseHorizontalPadding + collapsedSidebarInset.left,
               paddingRight: baseHorizontalPadding + collapsedSidebarInset.right,
             },
+            borderless && styles.borderless,
           ]}
           {...dragHandlers}
         >
@@ -87,4 +89,7 @@ const styles = StyleSheet.create((theme) => ({
     alignItems: "center",
     gap: theme.spacing[2],
   },
+  borderless: {
+    borderBottomWidth: 0,
+  },
 }));

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

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

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

@@ -36,6 +36,7 @@ import {
   GitPullRequest,
   Monitor,
   MoreVertical,
+  Plus,
 } from "lucide-react-native";
 import { NestableScrollContainer } from "react-native-draggable-flatlist";
 import { DraggableList, type DraggableRenderItemInfo } from "./draggable-list";
@@ -73,6 +74,7 @@ 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";
@@ -113,6 +115,7 @@ 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>;
@@ -1631,6 +1634,7 @@ export function SidebarWorkspaceList({
   isRefreshing = false,
   onRefresh,
   onWorkspacePress,
+  onAddProject,
   listFooterComponent,
   parentGestureRef,
 }: SidebarWorkspaceListProps) {
@@ -1900,7 +1904,18 @@ export function SidebarWorkspaceList({
   const content = (
     <>
       {projects.length === 0 ? (
-        <Text style={styles.emptyText}>No projects yet</Text>
+        <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>
       ) : (
         <DraggableList
           testID="sidebar-project-list"
@@ -1963,11 +1978,27 @@ 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,6 +565,18 @@ 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
@@ -586,6 +598,10 @@ export default function TerminalEmulator({
       onPointerDown={() => {
         runtimeRef.current?.focus();
       }}
+      onContextMenu={(event) => {
+        event.preventDefault();
+        handleContextMenu();
+      }}
     >
       <div
         ref={hostRef}

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

@@ -1,11 +1,19 @@
-import type { PropsWithChildren, ReactElement } from "react";
+import { useState, type ComponentType, type PropsWithChildren, type ReactElement } from "react";
 import { Pressable, Text, View } from "react-native";
 import type { PressableProps, StyleProp, TextStyle, ViewStyle } from "react-native";
-import { StyleSheet } from "react-native-unistyles";
+import { StyleSheet, useUnistyles } 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",
@@ -67,6 +75,12 @@ const styles = StyleSheet.create((theme) => ({
   textDestructive: {
     color: theme.colors.palette.white,
   },
+  textGhost: {
+    color: theme.colors.foregroundMuted,
+  },
+  textGhostHovered: {
+    color: theme.colors.foreground,
+  },
 }));
 
 export function Button({
@@ -83,11 +97,14 @@ export function Button({
   Omit<PressableProps, "style"> & {
     variant?: ButtonVariant;
     size?: ButtonSize;
-    leftIcon?: ReactElement | null;
+    leftIcon?: LeftIcon;
     style?: StyleProp<ViewStyle>;
     textStyle?: StyleProp<TextStyle>;
   }
 >) {
+  const [hovered, setHovered] = useState(false);
+  const { theme } = useUnistyles();
+
   const variantStyle =
     variant === "default"
       ? styles.default
@@ -100,19 +117,47 @@ 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,
@@ -122,7 +167,7 @@ export function Button({
         style,
       ]}
     >
-      {leftIcon ? <View>{leftIcon}</View> : null}
+      {renderIcon()}
       <Text style={resolvedTextStyle}>{children}</Text>
     </Pressable>
   );

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

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

packages/app/src/contexts/explorer-sidebar-animation-context.tsx

@@ -4,6 +4,10 @@ import { useSharedValue, withTiming, Easing, type SharedValue } from "react-nati
 import { type GestureType } from "react-native-gesture-handler";
 import { UnistylesRuntime } from "react-native-unistyles";
 import { usePanelStore } from "@/stores/panel-store";
+import {
+  getRightSidebarAnimationTargets,
+  shouldSyncSidebarAnimation,
+} from "@/utils/sidebar-animation-state";
 
 const ANIMATION_DURATION = 220;
 const ANIMATION_EASING = Easing.bezier(0.25, 0.1, 0.25, 1);
@@ -31,55 +35,59 @@ export function ExplorerSidebarAnimationProvider({ children }: { children: React
   const isOpen = isMobile ? mobileView === "file-explorer" : desktopFileExplorerOpen;
 
   // Right sidebar: closed = +windowWidth (off-screen right), open = 0
-  const translateX = useSharedValue(isOpen ? 0 : windowWidth);
-  const backdropOpacity = useSharedValue(isOpen ? 1 : 0);
+  const initialTargets = getRightSidebarAnimationTargets({ isOpen, windowWidth });
+  const translateX = useSharedValue(initialTargets.translateX);
+  const backdropOpacity = useSharedValue(initialTargets.backdropOpacity);
   const isGesturing = useSharedValue(false);
   const closeGestureRef = useRef<GestureType | undefined>(undefined);
 
   // Track previous isOpen to detect changes
   const prevIsOpen = useRef(isOpen);
+  const prevWindowWidth = useRef(windowWidth);
 
   // Sync animation with store state changes (e.g., backdrop tap, programmatic open/close)
   useEffect(() => {
-    // Skip if this is initial render or if we're mid-gesture
-    if (prevIsOpen.current === isOpen) {
-      return;
-    }
+    const didStateChange = shouldSyncSidebarAnimation({
+      previousIsOpen: prevIsOpen.current,
+      nextIsOpen: isOpen,
+      previousWindowWidth: prevWindowWidth.current,
+      nextWindowWidth: windowWidth,
+    });
     const previousIsOpen = prevIsOpen.current;
     prevIsOpen.current = isOpen;
+    prevWindowWidth.current = windowWidth;
+
+    if (!didStateChange) {
+      return;
+    }
 
     // Don't animate if we're in the middle of a gesture - the gesture handler will handle it
     if (isGesturing.value) {
       return;
     }
 
-    if (isOpen) {
-      translateX.value = withTiming(0, {
+    const targets = getRightSidebarAnimationTargets({ isOpen, windowWidth });
+
+    if (previousIsOpen !== isOpen) {
+      translateX.value = withTiming(targets.translateX, {
         duration: ANIMATION_DURATION,
         easing: ANIMATION_EASING,
       });
-      backdropOpacity.value = withTiming(1, {
-        duration: ANIMATION_DURATION,
-        easing: ANIMATION_EASING,
-      });
-    } else {
-      translateX.value = withTiming(windowWidth, {
-        duration: ANIMATION_DURATION,
-        easing: ANIMATION_EASING,
-      });
-      backdropOpacity.value = withTiming(0, {
+      backdropOpacity.value = withTiming(targets.backdropOpacity, {
         duration: ANIMATION_DURATION,
         easing: ANIMATION_EASING,
       });
+      return;
     }
+
+    translateX.value = targets.translateX;
+    backdropOpacity.value = targets.backdropOpacity;
   }, [
     isOpen,
     translateX,
     backdropOpacity,
     windowWidth,
     isGesturing,
-    mobileView,
-    desktopFileExplorerOpen,
   ]);
 
   const animateToOpen = () => {

packages/app/src/contexts/sidebar-animation-context.tsx

@@ -12,6 +12,10 @@ import { useSharedValue, withTiming, Easing, type SharedValue } from "react-nati
 import { type GestureType } from "react-native-gesture-handler";
 import { UnistylesRuntime } from "react-native-unistyles";
 import { usePanelStore } from "@/stores/panel-store";
+import {
+  getLeftSidebarAnimationTargets,
+  shouldSyncSidebarAnimation,
+} from "@/utils/sidebar-animation-state";
 
 const ANIMATION_DURATION = 220;
 const ANIMATION_EASING = Easing.bezier(0.25, 0.1, 0.25, 1);
@@ -38,46 +42,53 @@ export function SidebarAnimationProvider({ children }: { children: ReactNode })
   const isOpen = isMobile ? mobileView === "agent-list" : desktopAgentListOpen;
 
   // Initialize based on current state
-  const translateX = useSharedValue(isOpen ? 0 : -windowWidth);
-  const backdropOpacity = useSharedValue(isOpen ? 1 : 0);
+  const initialTargets = getLeftSidebarAnimationTargets({ isOpen, windowWidth });
+  const translateX = useSharedValue(initialTargets.translateX);
+  const backdropOpacity = useSharedValue(initialTargets.backdropOpacity);
   const isGesturing = useSharedValue(false);
   const closeGestureRef = useRef<GestureType | undefined>(undefined);
 
   // Track previous isOpen to detect changes
   const prevIsOpen = useRef(isOpen);
+  const prevWindowWidth = useRef(windowWidth);
 
   // Sync animation with store state changes (e.g., backdrop tap, programmatic open/close)
   useEffect(() => {
-    // Skip if this is initial render or if we're mid-gesture
-    if (prevIsOpen.current === isOpen) {
+    const didStateChange = shouldSyncSidebarAnimation({
+      previousIsOpen: prevIsOpen.current,
+      nextIsOpen: isOpen,
+      previousWindowWidth: prevWindowWidth.current,
+      nextWindowWidth: windowWidth,
+    });
+    const previousIsOpen = prevIsOpen.current;
+    prevIsOpen.current = isOpen;
+    prevWindowWidth.current = windowWidth;
+
+    if (!didStateChange) {
       return;
     }
-    prevIsOpen.current = isOpen;
 
     // Don't animate if we're in the middle of a gesture - the gesture handler will handle it
     if (isGesturing.value) {
       return;
     }
 
-    if (isOpen) {
-      translateX.value = withTiming(0, {
+    const targets = getLeftSidebarAnimationTargets({ isOpen, windowWidth });
+
+    if (previousIsOpen !== isOpen) {
+      translateX.value = withTiming(targets.translateX, {
         duration: ANIMATION_DURATION,
         easing: ANIMATION_EASING,
       });
-      backdropOpacity.value = withTiming(1, {
-        duration: ANIMATION_DURATION,
-        easing: ANIMATION_EASING,
-      });
-    } else {
-      translateX.value = withTiming(-windowWidth, {
-        duration: ANIMATION_DURATION,
-        easing: ANIMATION_EASING,
-      });
-      backdropOpacity.value = withTiming(0, {
+      backdropOpacity.value = withTiming(targets.backdropOpacity, {
         duration: ANIMATION_DURATION,
         easing: ANIMATION_EASING,
       });
+      return;
     }
+
+    translateX.value = targets.translateX;
+    backdropOpacity.value = targets.backdropOpacity;
   }, [isOpen, translateX, backdropOpacity, windowWidth, isGesturing]);
 
   const animateToOpen = useCallback(() => {

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

@@ -27,3 +27,12 @@ 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,6 +37,13 @@ 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;
@@ -44,6 +51,7 @@ 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);
@@ -73,6 +81,7 @@ export interface DesktopHostBridge {
   dialog?: DesktopDialogBridge;
   notification?: DesktopNotificationBridge;
   opener?: DesktopOpenerBridge;
+  menu?: DesktopMenuBridge;
 }
 
 declare global {

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

@@ -10,8 +10,15 @@ const CHANGELOG_URL = "https://paseo.sh/changelog";
 
 export function UpdateBanner() {
   const { theme } = useUnistyles();
-  const { isDesktop, status, availableUpdate, checkForUpdates, installUpdate, isInstalling } =
-    useDesktopAppUpdater();
+  const {
+    isDesktop,
+    status,
+    availableUpdate,
+    errorMessage,
+    checkForUpdates,
+    installUpdate,
+    isInstalling,
+  } = useDesktopAppUpdater();
   const [dismissed, setDismissed] = useState(false);
   const intervalRef = useRef<ReturnType<typeof setInterval> | null>(null);
 
@@ -33,24 +40,36 @@ export function UpdateBanner() {
 
   if (!isDesktop) return null;
   if (dismissed) return null;
-  if (status !== "available" && status !== "installed") return null;
+  if (status !== "available" && status !== "installed" && status !== "installing" && status !== "error")
+    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">
-      <View style={styles.banner}>
-        <Pressable onPress={() => setDismissed(true)} hitSlop={8} style={styles.closeButton}>
-          <X size={14} color={theme.colors.foregroundMuted} />
-        </Pressable>
+      <Pressable onPress={() => setDismissed(true)} hitSlop={8} style={styles.closeButton}>
+        <X size={12} color={theme.colors.foregroundMuted} />
+      </Pressable>
 
+      <View style={styles.banner}>
         <View style={styles.textSection}>
-          <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>
+          <Text style={styles.title}>{getTitle()}</Text>
+          <Text style={styles.subtitle}>{getSubtitle()}</Text>
         </View>
 
         <View style={styles.actions}>
@@ -61,7 +80,7 @@ export function UpdateBanner() {
             <Text style={styles.outlineButtonText}>What's new</Text>
           </Pressable>
 
-          {!isInstalled && (
+          {!isInstalled && !isError && (
             <Pressable
               onPress={() => void installUpdate()}
               disabled={isInstalling}
@@ -76,6 +95,15 @@ 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>
@@ -109,15 +137,21 @@ const styles = StyleSheet.create((theme) => ({
   },
   closeButton: {
     position: "absolute",
-    top: theme.spacing[2],
-    left: theme.spacing[2],
-    padding: theme.spacing[1],
+    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",
     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,6 +13,7 @@ import { useHosts } from "@/runtime/host-runtime";
 import { useHostRuntimeClient, useHostRuntimeIsConnected } from "@/runtime/host-runtime";
 import {
   useFormPreferences,
+  mergeProviderPreferences,
   type FormPreferences,
   type ProviderPreferences,
 } from "./use-form-preferences";
@@ -693,26 +694,23 @@ export function useAgentFormState(options: UseAgentFormStateOptions = {}): UseAg
   const persistFormPreferences = useCallback(async () => {
     const resolvedModel = resolveEffectiveModel(availableModels, formState.model);
     const modelId = resolvedModel?.id ?? formState.model;
-    const existingProviderPrefs = preferences?.providerPreferences?.[formState.provider];
-
-    const nextProviderPrefs: ProviderPreferences = {
-      model: modelId || undefined,
-      mode: formState.modeId || undefined,
-      thinkingByModel: {
-        ...existingProviderPrefs?.thinkingByModel,
-        ...(modelId && formState.thinkingOptionId
-          ? { [modelId]: formState.thinkingOptionId }
-          : {}),
-      },
-    };
-
-    await updatePreferences({
+    const nextPreferences = mergeProviderPreferences({
+      preferences: preferences ?? {},
       provider: formState.provider,
-      providerPreferences: {
-        ...preferences?.providerPreferences,
-        [formState.provider]: nextProviderPrefs,
-      },
+      updates: {
+        model: modelId || undefined,
+        mode: formState.modeId || undefined,
+        ...(modelId && formState.thinkingOptionId
+          ? {
+              thinkingByModel: {
+                [modelId]: formState.thinkingOptionId,
+              },
+            }
+          : {}),
+      } satisfies Partial<ProviderPreferences>,
     });
+
+    await updatePreferences(nextPreferences);
   }, [
     availableModels,
     formState.model,

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

@@ -0,0 +1,57 @@
+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,6 +2,7 @@ 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"];
@@ -35,6 +36,36 @@ 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,6 +30,16 @@ 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: "dark",
+  theme: "auto",
   manageBuiltInDaemon: true,
 };
 

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

@@ -15,7 +15,10 @@ 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";
@@ -33,6 +36,10 @@ 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" }
@@ -1073,6 +1080,7 @@ 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 {
@@ -1161,20 +1169,40 @@ export class HostRuntimeStore {
     }
   }
 
-  private async bootstrapDesktop(): Promise<void> {
+  async bootstrapDesktop(): Promise<HostRuntimeBootstrapResult> {
     try {
       const daemon = await startDesktopDaemon();
-      const connection = connectionFromListen(daemon.listen);
-      if (!connection || !daemon.serverId) {
-        return;
+      const listenAddress = daemon.listen.trim();
+      const serverId = daemon.serverId.trim();
+      if (!listenAddress) {
+        return {
+          ok: false,
+          error: "Desktop daemon did not return a listen address.",
+        };
       }
-      await this.upsertHostConnection({
-        serverId: daemon.serverId,
-        label: daemon.hostname ?? undefined,
-        connection,
-      });
+      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) {
-      console.warn("[HostRuntime] Failed to bootstrap desktop daemon", error);
+      return {
+        ok: false,
+        error: toErrorMessage(error),
+      };
     }
   }
 
@@ -1280,6 +1308,36 @@ 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,
@@ -1441,6 +1499,100 @@ 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,27 +1,22 @@
 import { useEffect } from "react";
-import { View, Text, Pressable } from "react-native";
-import { StyleSheet, UnistylesRuntime, useUnistyles } from "react-native-unistyles";
-import { useSafeAreaInsets } from "react-native-safe-area-context";
+import { View, Text } from "react-native";
+import { StyleSheet, UnistylesRuntime } from "react-native-unistyles";
 import { FolderOpen } from "lucide-react-native";
 import { PaseoLogo } from "@/components/icons/paseo-logo";
-import { SidebarMenuToggle } from "@/components/headers/menu-header";
+import { Button } from "@/components/ui/button";
+import { MenuHeader } from "@/components/headers/menu-header";
 import { useOpenProjectPicker } from "@/hooks/use-open-project-picker";
 import { usePanelStore } from "@/stores/panel-store";
-import { useDesktopDragHandlers, useTrafficLightPadding } from "@/utils/desktop-window";
+import { useSessionStore } from "@/stores/session-store";
+import { useDesktopDragHandlers } 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(() => {
@@ -32,22 +27,24 @@ export function OpenProjectScreen({ serverId }: { serverId: string }) {
 
   return (
     <View style={styles.container} {...dragHandlers}>
-      <View style={[styles.menuToggle, { paddingTop: insets.top, paddingLeft: collapsedSidebarInset.left, paddingRight: collapsedSidebarInset.right }]}>
-        <SidebarMenuToggle />
-      </View>
+      <MenuHeader borderless />
       <View style={styles.content}>
-        <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 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>
       </View>
     </View>
   );
@@ -59,43 +56,32 @@ 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: theme.spacing[6],
+    gap: 0,
     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",
   },
-  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: {
+  subtitle: {
     color: theme.colors.foregroundMuted,
-    fontSize: theme.fontSize.sm,
-    fontWeight: theme.fontWeight.normal,
+    fontSize: theme.fontSize.base,
+    textAlign: "center",
   },
 }));

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

@@ -1,10 +1,14 @@
 import { useMemo, useState, useCallback, useEffect } from "react";
-import { View } from "react-native";
+import { View, Text } 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();
@@ -44,13 +48,26 @@ function SessionsScreenContent({ serverId }: { serverId: string }) {
   return (
     <View style={styles.container}>
       <MenuHeader title="Sessions" />
-      <AgentList
-        agents={sortedAgents}
-        showCheckoutInfo={false}
-        isRefreshing={isManualRefresh && isRevalidating}
-        onRefresh={handleRefresh}
-        showAttentionIndicator={false}
-      />
+      {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}
+        />
+      )}
     </View>
   );
 }
@@ -60,4 +77,15 @@ 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/settings-screen.tsx

@@ -896,12 +896,6 @@ export default function SettingsScreen() {
   const handleThemeChange = useCallback(
     (newTheme: AppSettings["theme"]) => {
       void updateSettings({ theme: newTheme });
-      if (newTheme === "auto") {
-        UnistylesRuntime.setAdaptiveThemes(true);
-      } else {
-        UnistylesRuntime.setAdaptiveThemes(false);
-        UnistylesRuntime.setTheme(newTheme);
-      }
     },
     [updateSettings],
   );

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

@@ -1,29 +1,318 @@
-import { Text, View } from "react-native";
-import { StyleSheet } from "react-native-unistyles";
+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 { 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,
-    justifyContent: "center",
     alignItems: "center",
+    justifyContent: "center",
     backgroundColor: theme.colors.surface0,
+    paddingHorizontal: theme.spacing[8],
+    paddingVertical: theme.spacing[8],
   },
-  status: {
+  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: {
     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() {
+export function StartupSplashScreen({ bootstrapState }: StartupSplashScreenProps) {
+  const { theme } = useUnistyles();
   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} {...dragHandlers}>
-      <PaseoLogo size={96} />
-      <Text style={styles.status}>Starting up…</Text>
+    <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>
   );
 }

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

@@ -8,6 +8,7 @@ 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,
@@ -168,7 +169,12 @@ export class TerminalEmulatorRuntime {
     let webglAddon: WebglAddon | null = null;
     terminal.loadAddon(fitAddon);
     terminal.loadAddon(unicode11Addon);
-    terminal.loadAddon(new WebLinksAddon());
+    terminal.loadAddon(
+      new WebLinksAddon((event, uri) => {
+        event.preventDefault();
+        void openExternalUrl(uri);
+      }),
+    );
     terminal.loadAddon(new SearchAddon({ highlightLimit: 20_000 }));
     terminal.loadAddon(new ClipboardAddon());
     try {

packages/app/src/utils/sidebar-animation-state.test.ts

@@ -0,0 +1,44 @@
+import { describe, expect, it } from "vitest";
+import {
+  getLeftSidebarAnimationTargets,
+  getRightSidebarAnimationTargets,
+  shouldSyncSidebarAnimation,
+} from "./sidebar-animation-state";
+
+describe("sidebar-animation-state", () => {
+  it("requests a sync when the open state changes", () => {
+    expect(
+      shouldSyncSidebarAnimation({
+        previousIsOpen: false,
+        nextIsOpen: true,
+        previousWindowWidth: 390,
+        nextWindowWidth: 390,
+      }),
+    ).toBe(true);
+  });
+
+  it("requests a sync when the viewport width changes", () => {
+    expect(
+      shouldSyncSidebarAnimation({
+        previousIsOpen: false,
+        nextIsOpen: false,
+        previousWindowWidth: 390,
+        nextWindowWidth: 430,
+      }),
+    ).toBe(true);
+  });
+
+  it("keeps the left sidebar fully off-screen when closed", () => {
+    expect(getLeftSidebarAnimationTargets({ isOpen: false, windowWidth: 430 })).toEqual({
+      translateX: -430,
+      backdropOpacity: 0,
+    });
+  });
+
+  it("keeps the right sidebar fully off-screen when closed", () => {
+    expect(getRightSidebarAnimationTargets({ isOpen: false, windowWidth: 430 })).toEqual({
+      translateX: 430,
+      backdropOpacity: 0,
+    });
+  });
+});

packages/app/src/utils/sidebar-animation-state.ts

@@ -0,0 +1,41 @@
+interface SidebarAnimationSyncInput {
+  previousIsOpen: boolean;
+  nextIsOpen: boolean;
+  previousWindowWidth: number;
+  nextWindowWidth: number;
+}
+
+interface SidebarAnimationTargetInput {
+  isOpen: boolean;
+  windowWidth: number;
+}
+
+interface SidebarAnimationTargets {
+  translateX: number;
+  backdropOpacity: number;
+}
+
+export function shouldSyncSidebarAnimation(input: SidebarAnimationSyncInput): boolean {
+  return (
+    input.previousIsOpen !== input.nextIsOpen ||
+    input.previousWindowWidth !== input.nextWindowWidth
+  );
+}
+
+export function getLeftSidebarAnimationTargets(
+  input: SidebarAnimationTargetInput,
+): SidebarAnimationTargets {
+  return {
+    translateX: input.isOpen ? 0 : -input.windowWidth,
+    backdropOpacity: input.isOpen ? 1 : 0,
+  };
+}
+
+export function getRightSidebarAnimationTargets(
+  input: SidebarAnimationTargetInput,
+): SidebarAnimationTargets {
+  return {
+    translateX: input.isOpen ? 0 : input.windowWidth,
+    backdropOpacity: input.isOpen ? 1 : 0,
+  };
+}

packages/cli/src/cli.ts

@@ -2,8 +2,11 @@ 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";
@@ -137,6 +140,15 @@ 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

@@ -0,0 +1,31 @@
+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

@@ -0,0 +1,24 @@
+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

@@ -0,0 +1,69 @@
+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

@@ -0,0 +1,24 @@
+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

@@ -0,0 +1,23 @@
+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

@@ -0,0 +1,41 @@
+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

@@ -0,0 +1,60 @@
+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

@@ -0,0 +1,126 @@
+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

@@ -0,0 +1,127 @@
+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

@@ -0,0 +1,47 @@
+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,29 +35,75 @@ function resolveNodePathFromPidUnix(pid: number): NodePathFromPidResult {
   return resolved ? { nodePath: resolved } : { nodePath: null, error: "ps returned an empty command path" };
 }
 
-function resolveNodePathFromPidWindows(pid: number): NodePathFromPidResult {
-  const result = spawnSync(
-    "wmic",
-    ["process", "where", `ProcessId=${pid}`, "get", "ExecutablePath", "/VALUE"],
-    { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] },
-  );
+function runProcessProbe(command: string, args: string[]): {
+  resolved: string | null;
+  error?: string;
+} {
+  const result = spawnSync(command, args, {
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"],
+  });
 
   if (result.error) {
-    return { nodePath: null, error: `wmic failed: ${normalizeError(result.error)}` };
+    return { resolved: null, error: `${command} failed: ${normalizeError(result.error)}` };
   }
 
   if ((result.status ?? 1) !== 0) {
     const details = result.stderr?.trim();
     return {
-      nodePath: null,
-      error: details ? `wmic failed: ${details}` : `wmic exited with code ${result.status ?? 1}`,
+      resolved: null,
+      error: details ? `${command} failed: ${details}` : `${command} exited with code ${result.status ?? 1}`,
     };
   }
 
-  // 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" };
+  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" };
 }
 
 export function resolveNodePathFromPid(pid: number): NodePathFromPidResult {

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

@@ -15,7 +15,8 @@ interface ProviderBinaryStatus {
 
 interface DaemonStatus {
   serverId: string | null;
-  status: "running" | "stopped" | "unresponsive";
+  localDaemon: "running" | "stopped" | "stale_pid" | "unresponsive";
+  connectedDaemon: "reachable" | "unreachable" | "not_probed";
   home: string;
   listen: string;
   hostname: string | null;
@@ -85,11 +86,16 @@ function createStatusSchema(status: DaemonStatus): OutputSchema<StatusRow> {
         header: "VALUE",
         field: "value",
         color: (_, item) => {
-          if (item.key === "Status") {
+          if (item.key === "Local Daemon") {
             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";
@@ -106,7 +112,8 @@ function createStatusSchema(status: DaemonStatus): OutputSchema<StatusRow> {
 function toStatusRows(status: DaemonStatus): StatusRow[] {
   const rows: StatusRow[] = [
     { key: "Server ID", value: status.serverId ?? "-" },
-    { key: "Status", value: status.status },
+    { key: "Local Daemon", value: status.localDaemon },
+    { key: "Connected Daemon", value: status.connectedDaemon },
     { key: "Home", value: status.home },
     { key: "Listen", value: status.listen },
     { key: "Hostname", value: status.hostname ?? "-" },
@@ -199,6 +206,7 @@ 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;
@@ -211,38 +219,60 @@ export async function runStatusCommand(
     daemonNode = "unknown (no PID available)";
   }
   const cliNode = process.execPath;
-  let status: DaemonStatus["status"] = state.running ? "running" : "stopped";
+  let localDaemon: DaemonStatus["localDaemon"] = state.running ? "running" : "stopped";
+  let connectedDaemon: DaemonStatus["connectedDaemon"] = "not_probed";
   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 (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(() => {});
+  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`,
+          );
         }
-      } else {
-        status = "unresponsive";
-        note = appendNote(note, `Daemon PID is running but websocket at ${host} is not reachable`);
+      } 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 if (state.running) {
+      connectedDaemon = "unreachable";
+      localDaemon = "unresponsive";
+      note = appendNote(
+        note,
+        `Local daemon PID is running but websocket at ${host} is not reachable`,
+      );
     } else {
-      note = appendNote(note, "Daemon is configured for unix socket listen; API probe skipped");
+      connectedDaemon = "unreachable";
     }
+  } else {
+    note = appendNote(note, "Daemon is configured for unix socket listen; API probe skipped");
   }
 
   const cliVersion = resolveCliVersion();
@@ -258,7 +288,8 @@ export async function runStatusCommand(
 
   const daemonStatus: DaemonStatus = {
     serverId,
-    status,
+    localDaemon,
+    connectedDaemon,
     home: state.home,
     listen: state.listen,
     hostname: state.pidInfo?.hostname ?? null,

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

@@ -0,0 +1,34 @@
+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

@@ -0,0 +1,118 @@
+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

@@ -0,0 +1,82 @@
+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

@@ -0,0 +1,88 @@
+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

@@ -0,0 +1,161 @@
+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

@@ -0,0 +1,80 @@
+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

@@ -0,0 +1,147 @@
+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

@@ -0,0 +1,52 @@
+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

@@ -0,0 +1,43 @@
+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

@@ -0,0 +1,68 @@
+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

@@ -0,0 +1,32 @@
+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

@@ -0,0 +1,27 @@
+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

@@ -0,0 +1,32 @@
+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

@@ -0,0 +1,33 @@
+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

@@ -0,0 +1,33 @@
+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

@@ -0,0 +1,88 @@
+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

@@ -0,0 +1,195 @@
+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

@@ -0,0 +1,141 @@
+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,6 +40,9 @@ 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,6 +40,8 @@ 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,6 +29,17 @@ 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",
@@ -211,6 +222,36 @@ 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,11 +31,6 @@ 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",
@@ -47,7 +42,7 @@ const EXPECTED_CLAUDE_MODELS = [
     descriptionFragment: "Most capable",
   },
   {
-    id: "claude-haiku-4-5-20251001",
+    id: "claude-haiku-4-5",
     model: "Haiku 4.5",
     descriptionFragment: "Fastest",
   },
@@ -207,10 +202,13 @@ 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.includes("openai/gpt-5.3-codex-spark"),
-      "opencode output should include openai/gpt-5.3-codex-spark",
+      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",
     );
     console.log("✓ provider models opencode returns namespaced model IDs\n");
   }
@@ -269,8 +267,8 @@ try {
       "--quiet should print the current Claude catalog IDs",
     );
     assert(
-      claudeModelsFromJson.some((m) => m.id === "claude-sonnet-4-5-20250929"),
-      "captured --json output should still include the Claude default model id",
+      claudeModelsFromJson.some((m) => m.id === "claude-sonnet-4-6"),
+      "captured --json output should include the current Claude everyday model id",
     );
     console.log("✓ provider models --quiet outputs model IDs only\n");
   }

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

@@ -0,0 +1,85 @@
+#!/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

@@ -0,0 +1,99 @@
+#!/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,6 +333,7 @@ export async function runPaseoCli(
   options?: {
     timeout?: number;
     cwd?: string;
+    env?: NodeJS.ProcessEnv;
   },
 ): Promise<{ exitCode: number; stdout: string; stderr: string }> {
   const timeout = options?.timeout ?? 60000;
@@ -348,6 +349,7 @@ 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"],
@@ -399,7 +401,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 },
+      opts?: { timeout?: number; cwd?: string; env?: NodeJS.ProcessEnv },
     ) => Promise<{
       exitCode: number;
       stdout: string;
@@ -409,7 +411,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 }) =>
+  const paseo = (args: string[], opts?: { timeout?: number; cwd?: string; env?: NodeJS.ProcessEnv }) =>
     runPaseoCli(ctx, args, opts);
 
   return {

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

@@ -2,6 +2,7 @@ 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,
@@ -140,6 +141,13 @@ 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 ?? "")
@@ -148,8 +156,6 @@ function buildDesktopDaemonCorsOriginsEnv(): string | undefined {
       .filter((value) => value.length > 0),
   );
 
-  origins.add("paseo://app");
-
   const devServerUrl = process.env.EXPO_DEV_URL ?? DEFAULT_ELECTRON_DEV_SERVER_URL;
   try {
     const parsed = new URL(devServerUrl);
@@ -305,6 +311,16 @@ 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,
@@ -315,6 +331,12 @@ 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
@@ -329,15 +351,26 @@ 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}` : ""}`);
@@ -346,6 +379,15 @@ 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,4 +1,9 @@
-import { app, Menu, BrowserWindow } from "electron";
+import { app, Menu, BrowserWindow, ipcMain } from "electron";
+
+type ShowContextMenuInput = {
+  kind?: "terminal";
+  hasSelection?: boolean;
+};
 
 function withBrowserWindow(
   callback: (win: BrowserWindow) => void,
@@ -89,4 +94,36 @@ 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

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

packages/desktop/src/preload.ts

@@ -1,4 +1,3 @@
-import "electron-log/preload";
 import { contextBridge, ipcRenderer } from "electron";
 
 type EventHandler = (payload: unknown) => void;
@@ -27,6 +26,8 @@ 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);
@@ -52,4 +53,8 @@ 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 { readBadgeCount } from "./window-manager";
+import { getTitleBarOverlayOptions, readBadgeCount, readWindowTheme } from "./window-manager";
 
 describe("window-manager", () => {
   describe("readBadgeCount", () => {
@@ -20,4 +20,35 @@ 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 } from "electron";
+import { app, BrowserWindow, ipcMain, nativeTheme } from "electron";
 import {
   createWindowMoveState,
   readWindowMovePayload,
@@ -14,6 +14,28 @@ 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).
@@ -101,6 +123,20 @@ 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,6 +65,7 @@
     "@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,5 +1,6 @@
 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";
@@ -55,13 +56,30 @@ 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);
 
@@ -100,7 +118,22 @@ async function main(): Promise<void> {
     resolveWorkerEntry: () => workerEntry,
     workerArgs: config.workerArgs,
     workerEnv,
-    workerExecArgv: resolveWorkerExecArgv(workerEntry),
+    workerExecArgv,
+    resolveWorkerSpawnSpec: packagedNodeEntrypointRunner
+      ? (resolvedWorkerEntry) => ({
+          command: process.execPath,
+          args: [
+            packagedNodeEntrypointRunner,
+            "node-script",
+            resolvedWorkerEntry,
+            ...config.workerArgs,
+          ],
+          env: {
+            ...workerEnv,
+            ELECTRON_RUN_AS_NODE: "1",
+          },
+        })
+      : undefined,
     restartOnCrash: config.devMode,
     onSupervisorExit: releaseLock,
   });

packages/server/scripts/supervisor.ts

@@ -1,4 +1,4 @@
-import { fork, type ChildProcess } from "child_process";
+import { fork, spawn, type ChildProcess } from "child_process";
 
 type WorkerLifecycleMessage =
   | {
@@ -16,6 +16,11 @@ 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;
 };
@@ -47,6 +52,7 @@ 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;
@@ -84,11 +90,19 @@ export function runSupervisor(options: SupervisorOptions): void {
       return;
     }
 
-    child = fork(workerEntry, workerArgs, {
-      stdio: "inherit",
-      env: workerEnv,
-      execArgv: workerExecArgv,
-    });
+    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.on("message", (msg: unknown) => {
       const lifecycleMessage = parseLifecycleMessage(msg);

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

@@ -241,6 +241,82 @@ 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"];
@@ -277,6 +353,110 @@ 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"];
 
@@ -2677,6 +2857,261 @@ 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,3 +1,5 @@
+import type { AgentAttentionReason } from "../shared/agent-attention-notification.js";
+
 export type ClientAttentionState = {
   deviceType: "web" | "mobile" | null;
   focusedAgentId: string | null;
@@ -5,8 +7,6 @@ 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,6 +860,39 @@ 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,6 +134,40 @@ 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,6 +64,33 @@ 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,
@@ -186,7 +213,21 @@ export function findExecutable(
 
   if (deps.platform() === "win32") {
     try {
-      const out = deps.execSync(`where.exe ${trimmed}`, { encoding: "utf8" }).trim();
+      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 firstLine = out.split(/\r?\n/)[0]?.trim();
       return firstLine || null;
     } catch {

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

@@ -258,6 +258,7 @@ type ClaudeOptionsLogSummary = {
   hasCanUseTool: boolean;
   hasSpawnOverride: boolean;
   hasStderrHandler: boolean;
+  pathToClaudeCodeExecutable: string | null;
 };
 
 const MAX_RECENT_STDERR_CHARS = 4000;
@@ -301,6 +302,10 @@ 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,
   };
 }
 
@@ -1863,6 +1868,22 @@ 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,6 +99,10 @@ 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";
@@ -246,9 +250,8 @@ export async function createPaseoDaemon(
     // CORS - allow same-origin + configured origins
     const allowedOrigins = new Set([
       ...config.corsAllowedOrigins,
-      // Packaged desktop renderers may send `file://` or `null` as the origin.
-      "file://",
-      "null",
+      // Packaged desktop renderers use the custom paseo:// protocol scheme.
+      "paseo://app",
       // For TCP, add localhost variants
       ...(listenTarget.type === "tcp"
         ? [
@@ -374,6 +377,10 @@ 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, {
@@ -402,6 +409,28 @@ 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() },
@@ -410,6 +439,7 @@ 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;
@@ -634,6 +664,10 @@ export async function createPaseoDaemon(
       },
       projectRegistry,
       workspaceRegistry,
+      chatService,
+      loopService,
+      scheduleService,
+      checkoutDiffManager,
     );
     unsubscribeSpeechReadiness = subscribeSpeechReadiness((snapshot) => {
       wsServer?.publishSpeechReadiness(snapshot);
@@ -727,6 +761,7 @@ 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

@@ -0,0 +1,83 @@
+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

@@ -0,0 +1,114 @@
+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

@@ -0,0 +1,116 @@
+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

@@ -0,0 +1,152 @@
+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

@@ -0,0 +1,449 @@
+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

@@ -0,0 +1,30 @@
+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

@@ -0,0 +1,361 @@
+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

@@ -0,0 +1,50 @@
+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

@@ -0,0 +1,480 @@
+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

@@ -0,0 +1,876 @@
+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

@@ -0,0 +1,191 @@
+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

@@ -0,0 +1,28 @@
+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");
+  });
+});