Merge branch 'main' into dev

Resolve 38 conflicts preserving both sides' work:
- Server: DB-based registries (dev) + WorkspaceGitService/DaemonConfigStore (main)
- App: script proxy/voice MCP (dev) + pin/hide tabs/bootstrap boundary (main)
- Shared: WorkspaceScriptPayload (dev) + git/GitHub runtime schemas (main)
- Deleted workspace-registry-bootstrap.ts (dev's DB approach supersedes)

packages/cli/src/cli.ts

@@ -62,45 +62,39 @@ export function createCli(): Command {
     .option("--no-color", "disable colored output");
 
   // Primary agent commands (top-level)
-  addJsonAndDaemonHostOptions(
-    addLsOptions(program.command("ls")),
-  ).action(withOutput(runLsCommand));
+  addJsonAndDaemonHostOptions(addLsOptions(program.command("ls"))).action(withOutput(runLsCommand));
 
-  addJsonAndDaemonHostOptions(
-    addRunOptions(program.command("run")),
-  ).action(withOutput(runRunCommand));
+  addJsonAndDaemonHostOptions(addRunOptions(program.command("run"))).action(
+    withOutput(runRunCommand),
+  );
 
-  addDaemonHostOption(
-    addAttachOptions(program.command("attach")),
-  ).action(runAttachCommand);
+  addDaemonHostOption(addAttachOptions(program.command("attach"))).action(runAttachCommand);
 
-  addDaemonHostOption(
-    addLogsOptions(program.command("logs")),
-  ).action(runLogsCommand);
+  addDaemonHostOption(addLogsOptions(program.command("logs"))).action(runLogsCommand);
 
-  addJsonAndDaemonHostOptions(
-    addStopOptions(program.command("stop")),
-  ).action(withOutput(runStopCommand));
+  addJsonAndDaemonHostOptions(addStopOptions(program.command("stop"))).action(
+    withOutput(runStopCommand),
+  );
 
-  addJsonAndDaemonHostOptions(
-    addDeleteOptions(program.command("delete")),
-  ).action(withOutput(runDeleteCommand));
+  addJsonAndDaemonHostOptions(addDeleteOptions(program.command("delete"))).action(
+    withOutput(runDeleteCommand),
+  );
 
-  addJsonAndDaemonHostOptions(
-    addSendOptions(program.command("send")),
-  ).action(withOutput(runSendCommand));
+  addJsonAndDaemonHostOptions(addSendOptions(program.command("send"))).action(
+    withOutput(runSendCommand),
+  );
 
-  addJsonAndDaemonHostOptions(
-    addInspectOptions(program.command("inspect")),
-  ).action(withOutput(runInspectCommand));
+  addJsonAndDaemonHostOptions(addInspectOptions(program.command("inspect"))).action(
+    withOutput(runInspectCommand),
+  );
 
-  addJsonAndDaemonHostOptions(
-    addWaitOptions(program.command("wait")),
-  ).action(withOutput(runWaitCommand));
+  addJsonAndDaemonHostOptions(addWaitOptions(program.command("wait"))).action(
+    withOutput(runWaitCommand),
+  );
 
-  addJsonAndDaemonHostOptions(
-    addArchiveOptions(program.command("archive")),
-  ).action(withOutput(runArchiveCommand));
+  addJsonAndDaemonHostOptions(addArchiveOptions(program.command("archive"))).action(
+    withOutput(runArchiveCommand),
+  );
 
   // Top-level local daemon shortcuts
   program.addCommand(onboardCommand());

packages/cli/src/commands/agent/archive.ts

@@ -26,7 +26,7 @@ export const archiveSchema: OutputSchema<AgentArchiveResult> = {
 
 export function addArchiveOptions(cmd: Command): Command {
   return cmd
-    .description('Archive an agent (soft-delete)')
+    .description("Archive an agent (soft-delete)")
     .argument("<id>", "Agent ID, prefix, or name")
     .option("--force", "Force archive running agent (interrupts active run first)");
 }

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

@@ -10,6 +10,7 @@ import { addSendOptions, runSendCommand } from "./send.js";
 import { addInspectOptions, runInspectCommand } from "./inspect.js";
 import { addWaitOptions, runWaitCommand } from "./wait.js";
 import { addAttachOptions, runAttachCommand } from "./attach.js";
+import { addReloadOptions, runReloadCommand } from "./reload.js";
 import { runUpdateCommand } from "./update.js";
 import { withOutput } from "../../output/index.js";
 import {
@@ -22,41 +23,35 @@ export function createAgentCommand(): Command {
   const agent = new Command("agent").description("Manage agents (advanced operations)");
 
   // Primary agent commands (same as top-level)
-  addJsonAndDaemonHostOptions(
-    addLsOptions(agent.command("ls")),
-  ).action(withOutput(runLsCommand));
+  addJsonAndDaemonHostOptions(addLsOptions(agent.command("ls"))).action(withOutput(runLsCommand));
 
-  addJsonAndDaemonHostOptions(
-    addRunOptions(agent.command("run")),
-  ).action(withOutput(runRunCommand));
+  addJsonAndDaemonHostOptions(addRunOptions(agent.command("run"))).action(
+    withOutput(runRunCommand),
+  );
 
-  addDaemonHostOption(
-    addAttachOptions(agent.command("attach")),
-  ).action(runAttachCommand);
+  addDaemonHostOption(addAttachOptions(agent.command("attach"))).action(runAttachCommand);
 
-  addDaemonHostOption(
-    addLogsOptions(agent.command("logs")),
-  ).action(runLogsCommand);
+  addDaemonHostOption(addLogsOptions(agent.command("logs"))).action(runLogsCommand);
 
-  addJsonAndDaemonHostOptions(
-    addStopOptions(agent.command("stop")),
-  ).action(withOutput(runStopCommand));
+  addJsonAndDaemonHostOptions(addStopOptions(agent.command("stop"))).action(
+    withOutput(runStopCommand),
+  );
 
-  addJsonAndDaemonHostOptions(
-    addDeleteOptions(agent.command("delete")),
-  ).action(withOutput(runDeleteCommand));
+  addJsonAndDaemonHostOptions(addDeleteOptions(agent.command("delete"))).action(
+    withOutput(runDeleteCommand),
+  );
 
-  addJsonAndDaemonHostOptions(
-    addSendOptions(agent.command("send")),
-  ).action(withOutput(runSendCommand));
+  addJsonAndDaemonHostOptions(addSendOptions(agent.command("send"))).action(
+    withOutput(runSendCommand),
+  );
 
-  addJsonAndDaemonHostOptions(
-    addInspectOptions(agent.command("inspect")),
-  ).action(withOutput(runInspectCommand));
+  addJsonAndDaemonHostOptions(addInspectOptions(agent.command("inspect"))).action(
+    withOutput(runInspectCommand),
+  );
 
-  addJsonAndDaemonHostOptions(
-    addWaitOptions(agent.command("wait")),
-  ).action(withOutput(runWaitCommand));
+  addJsonAndDaemonHostOptions(addWaitOptions(agent.command("wait"))).action(
+    withOutput(runWaitCommand),
+  );
 
   // Advanced agent commands (less common operations)
   addJsonAndDaemonHostOptions(
@@ -68,9 +63,13 @@ export function createAgentCommand(): Command {
       .option("--list", "List available modes for this agent"),
   ).action(withOutput(runModeCommand));
 
-  addJsonAndDaemonHostOptions(
-    addArchiveOptions(agent.command("archive")),
-  ).action(withOutput(runArchiveCommand));
+  addJsonAndDaemonHostOptions(addArchiveOptions(agent.command("archive"))).action(
+    withOutput(runArchiveCommand),
+  );
+
+  addJsonAndDaemonHostOptions(addReloadOptions(agent.command("reload"))).action(
+    withOutput(runReloadCommand),
+  );
 
   addJsonAndDaemonHostOptions(
     agent

packages/cli/src/commands/agent/reload.ts

@@ -0,0 +1,106 @@
+import { Command } from "commander";
+import { connectToDaemon, getDaemonHost, resolveAgentId } from "../../utils/client.js";
+import type {
+  CommandOptions,
+  SingleResult,
+  OutputSchema,
+  CommandError,
+} from "../../output/index.js";
+
+export interface AgentReloadResult {
+  agentId: string;
+  status: "reloaded";
+  timelineSize: number;
+}
+
+export const reloadSchema: OutputSchema<AgentReloadResult> = {
+  idField: "agentId",
+  columns: [
+    { header: "AGENT ID", field: "agentId" },
+    { header: "STATUS", field: "status" },
+    { header: "TIMELINE", field: "timelineSize" },
+  ],
+};
+
+export function addReloadOptions(cmd: Command): Command {
+  return cmd
+    .description("Reload an agent (restarts the underlying process)")
+    .argument("<id>", "Agent ID, prefix, or name");
+}
+
+export interface AgentReloadOptions extends CommandOptions {
+  host?: string;
+}
+
+export type AgentReloadCommandResult = SingleResult<AgentReloadResult>;
+
+export async function runReloadCommand(
+  agentIdArg: string,
+  options: AgentReloadOptions,
+  _command: Command,
+): Promise<AgentReloadCommandResult> {
+  const host = getDaemonHost({ host: options.host as string | undefined });
+
+  if (!agentIdArg || agentIdArg.trim().length === 0) {
+    const error: CommandError = {
+      code: "MISSING_AGENT_ID",
+      message: "Agent ID is required",
+      details: "Usage: paseo agent reload <id-or-name>",
+    };
+    throw error;
+  }
+
+  let client;
+  try {
+    client = await connectToDaemon({ host: options.host as string | undefined });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    const error: CommandError = {
+      code: "DAEMON_NOT_RUNNING",
+      message: `Cannot connect to daemon at ${host}: ${message}`,
+      details: "Start the daemon with: paseo daemon start",
+    };
+    throw error;
+  }
+
+  try {
+    const agentsPayload = await client.fetchAgents({ filter: { includeArchived: true } });
+    const agents = agentsPayload.entries.map((entry) => entry.agent);
+    const agentId = resolveAgentId(agentIdArg, agents);
+    if (!agentId) {
+      const error: CommandError = {
+        code: "AGENT_NOT_FOUND",
+        message: `Agent not found: ${agentIdArg}`,
+        details: 'Use "paseo ls" to list available agents',
+      };
+      throw error;
+    }
+
+    const result = await client.refreshAgent(agentId);
+
+    await client.close();
+
+    return {
+      type: "single",
+      data: {
+        agentId: result.agentId,
+        status: "reloaded",
+        timelineSize: result.timelineSize ?? 0,
+      },
+      schema: reloadSchema,
+    };
+  } catch (err) {
+    await client.close().catch(() => {});
+
+    if (err && typeof err === "object" && "code" in err) {
+      throw err;
+    }
+
+    const message = err instanceof Error ? err.message : String(err);
+    const error: CommandError = {
+      code: "RELOAD_FAILED",
+      message: `Failed to reload agent: ${message}`,
+    };
+    throw error;
+  }
+}

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

@@ -1,4 +1,4 @@
-import { Command } from "commander";
+import { Command, Option } from "commander";
 import {
   getStructuredAgentResponse,
   StructuredAgentResponseError,
@@ -22,7 +22,8 @@ export function addRunOptions(cmd: Command): Command {
     .description("Create and start an agent with a task")
     .argument("<prompt>", "The task/prompt for the agent")
     .option("-d, --detach", "Run in background (detached)")
-    .option("--name <name>", "Assign a name/title to the agent")
+    .option("--title <title>", "Assign a title to the agent")
+    .addOption(new Option("--name <name>", "Hidden alias for --title").hideHelp())
     .option(
       "--provider <provider>",
       "Agent provider, or provider/model (e.g. codex or codex/gpt-5.4)",
@@ -82,6 +83,7 @@ export const agentRunSchema: OutputSchema<AgentRunResult> = {
 
 export interface AgentRunOptions extends CommandOptions {
   detach?: boolean;
+  title?: string;
   name?: string;
   provider?: string;
   model?: string;
@@ -324,6 +326,7 @@ export async function runRunCommand(
   }
 
   const resolvedProviderModel = resolveProviderAndModel(options);
+  const resolvedTitle = options.title ?? options.name;
 
   let client;
   try {
@@ -413,7 +416,7 @@ export async function runRunCommand(
           structuredAgent = await client.createAgent({
             provider: resolvedProviderModel.provider,
             cwd,
-            title: options.name,
+            title: resolvedTitle,
             modeId: options.mode,
             model: resolvedProviderModel.model,
             thinkingOptionId,
@@ -512,7 +515,7 @@ export async function runRunCommand(
     const agent = await client.createAgent({
       provider: resolvedProviderModel.provider,
       cwd,
-      title: options.name,
+      title: resolvedTitle,
       modeId: options.mode,
       model: resolvedProviderModel.model,
       thinkingOptionId,

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

@@ -20,9 +20,9 @@ export function createChatCommand(): Command {
       .option("--purpose <text>", "Room purpose/description"),
   ).action(withOutput(runCreateCommand));
 
-  addJsonAndDaemonHostOptions(
-    chat.command("ls").description("List chat rooms"),
-  ).action(withOutput(runLsCommand));
+  addJsonAndDaemonHostOptions(chat.command("ls").description("List chat rooms")).action(
+    withOutput(runLsCommand),
+  );
 
   addJsonAndDaemonHostOptions(
     chat

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

@@ -25,7 +25,9 @@ export async function runPostCommand(
       body,
       replyToMessageId: options.replyTo,
     });
-    const [message] = await attachAgentNamesToMessages(client, [toChatMessageRow(payload.message!)]);
+    const [message] = await attachAgentNamesToMessages(client, [
+      toChatMessageRow(payload.message!),
+    ]);
     return {
       type: "single",
       data: message!,

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

@@ -60,7 +60,9 @@ function renderChatMessageBlock(message: ChatMessageRow): string {
   const authorLabel = message.authorName
     ? `${message.authorName} (${message.author})`
     : message.author;
-  const lines = [`┌─ ${authorLabel} ── ${formatTimestamp(message.createdAt)} ── [msg ${message.id}]`];
+  const lines = [
+    `┌─ ${authorLabel} ── ${formatTimestamp(message.createdAt)} ── [msg ${message.id}]`,
+  ];
 
   if (message.replyTo !== "-") {
     lines.push(`│  reply-to: msg ${message.replyTo}`);

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

@@ -34,6 +34,7 @@ export function createDaemonCommand(): Command {
     .option("--port <port>", "Port for restarted daemon listen target")
     .option("--no-relay", "Disable relay on restarted daemon")
     .option("--no-mcp", "Disable Agent MCP on restarted daemon")
+    .option("--no-inject-mcp", "Disable auto-injecting the Paseo MCP into created agents")
     .option(
       "--allowed-hosts <hosts>",
       'Comma-separated Host allowlist values (example: "localhost,.example.com" or "true")',

packages/cli/src/commands/daemon/local-daemon.ts

@@ -12,6 +12,7 @@ export interface DaemonStartOptions {
   foreground?: boolean;
   relay?: boolean;
   mcp?: boolean;
+  injectMcp?: boolean;
   allowedHosts?: string;
 }
 
@@ -95,6 +96,9 @@ function buildRunnerArgs(options: DaemonStartOptions): string[] {
   if (options.mcp === false) {
     args.push("--no-mcp");
   }
+  if (options.injectMcp === false) {
+    args.push("--no-inject-mcp");
+  }
 
   return args;
 }
@@ -125,12 +129,7 @@ function resolveDaemonRunnerEntry(): string {
       try {
         const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8")) as { name?: string };
         if (packageJson.name === "@getpaseo/server") {
-          const distRunner = path.join(
-            currentDir,
-            "dist",
-            "scripts",
-            "supervisor-entrypoint.js",
-          );
+          const distRunner = path.join(currentDir, "dist", "scripts", "supervisor-entrypoint.js");
           if (existsSync(distRunner)) {
             return distRunner;
           }

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

@@ -60,6 +60,7 @@ function toStartOptions(options: CommandOptions): DaemonStartOptions {
     port: typeof options.port === "string" ? options.port : undefined,
     relay: typeof options.relay === "boolean" ? options.relay : undefined,
     mcp: typeof options.mcp === "boolean" ? options.mcp : undefined,
+    injectMcp: typeof options.injectMcp === "boolean" ? options.injectMcp : undefined,
     allowedHosts: typeof options.allowedHosts === "string" ? options.allowedHosts : undefined,
   };
 

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

@@ -32,10 +32,15 @@ function resolveNodePathFromPidUnix(pid: number): NodePathFromPidResult {
   }
 
   const resolved = result.stdout.trim();
-  return resolved ? { nodePath: resolved } : { nodePath: null, error: "ps returned an empty command path" };
+  return resolved
+    ? { nodePath: resolved }
+    : { nodePath: null, error: "ps returned an empty command path" };
 }
 
-function runProcessProbe(command: string, args: string[]): {
+function runProcessProbe(
+  command: string,
+  args: string[],
+): {
   resolved: string | null;
   error?: string;
 } {
@@ -52,16 +57,25 @@ function runProcessProbe(command: string, args: string[]): {
     const details = result.stderr?.trim();
     return {
       resolved: null,
-      error: details ? `${command} failed: ${details}` : `${command} exited with code ${result.status ?? 1}`,
+      error: details
+        ? `${command} failed: ${details}`
+        : `${command} exited with code ${result.status ?? 1}`,
     };
   }
 
   const resolved = result.stdout.trim();
-  return resolved ? { resolved } : { resolved: null, error: `${command} returned no executable path` };
+  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 }> = [
+  const probes: Array<{
+    label: string;
+    command: string;
+    args: string[];
+    parseValue?: (stdout: string) => string | null;
+  }> = [
     {
       label: "powershell-cim",
       command: "powershell",
@@ -103,7 +117,10 @@ function resolveNodePathFromPidWindows(pid: number): NodePathFromPidResult {
     }
   }
 
-  return { nodePath: null, error: errors.join("; ") || "could not resolve executable path from PID" };
+  return {
+    nodePath: null,
+    error: errors.join("; ") || "could not resolve executable path from PID",
+  };
 }
 
 export function resolveNodePathFromPid(pid: number): NodePathFromPidResult {

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

@@ -18,6 +18,7 @@ export function startCommand(): Command {
     .option("--foreground", "Run in foreground (don't daemonize)")
     .option("--no-relay", "Disable relay connection")
     .option("--no-mcp", "Disable the Agent MCP HTTP endpoint")
+    .option("--no-inject-mcp", "Disable auto-injecting the Paseo MCP into created agents")
     .option(
       "--allowed-hosts <hosts>",
       'Comma-separated Host allowlist values (example: "localhost,.example.com" or "true")',

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

@@ -2,11 +2,7 @@ import type { Command } from "commander";
 import { execFile } from "node:child_process";
 import { createRequire } from "node:module";
 import { promisify } from "node:util";
-import {
-  getOrCreateServerId,
-  findExecutable,
-  applyProviderEnv,
-} from "@getpaseo/server";
+import { getOrCreateServerId, findExecutable, applyProviderEnv } from "@getpaseo/server";
 
 const execFileAsync = promisify(execFile);
 import { tryConnectToDaemon } from "../../utils/client.js";
@@ -173,7 +169,9 @@ const PROVIDER_BINARIES: { label: string; binary: string }[] = [
   { label: "OpenCode", binary: "opencode" },
 ];
 
-async function checkProviderBinary(binary: string): Promise<{ path: string | null; version: string | null }> {
+async function checkProviderBinary(
+  binary: string,
+): Promise<{ path: string | null; version: string | null }> {
   const binaryPath = await findExecutable(binary);
   if (!binaryPath) {
     return { path: null, version: null };

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

@@ -10,25 +10,23 @@ 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(addLoopRunOptions(loop.command("run"))).action(
+    withOutput(runLoopRunCommand),
+  );
 
-  addJsonAndDaemonHostOptions(
-    addLoopLsOptions(loop.command("ls")),
-  ).action(withOutput(runLoopLsCommand));
+  addJsonAndDaemonHostOptions(addLoopLsOptions(loop.command("ls"))).action(
+    withOutput(runLoopLsCommand),
+  );
 
-  addJsonAndDaemonHostOptions(
-    addLoopInspectOptions(loop.command("inspect")),
-  ).action(withOutput(runLoopInspectCommand));
+  addJsonAndDaemonHostOptions(addLoopInspectOptions(loop.command("inspect"))).action(
+    withOutput(runLoopInspectCommand),
+  );
 
-  addDaemonHostOption(
-    addLoopLogsOptions(loop.command("logs")),
-  ).action(runLoopLogsCommand);
+  addDaemonHostOption(addLoopLogsOptions(loop.command("logs"))).action(runLoopLogsCommand);
 
-  addJsonAndDaemonHostOptions(
-    addLoopStopOptions(loop.command("stop")),
-  ).action(withOutput(runLoopStopCommand));
+  addJsonAndDaemonHostOptions(addLoopStopOptions(loop.command("stop"))).action(
+    withOutput(runLoopStopCommand),
+  );
 
   return loop;
 }

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

@@ -1,11 +1,6 @@
 import { Command } from "commander";
 import { connectToDaemon, getDaemonHost } from "../../utils/client.js";
-import type {
-  CommandOptions,
-  CommandError,
-  OutputSchema,
-  ListResult,
-} from "../../output/index.js";
+import type { CommandOptions, CommandError, OutputSchema, ListResult } from "../../output/index.js";
 import type { LoopDaemonClient, LoopRecord } from "./types.js";
 
 interface InspectRow {
@@ -44,10 +39,16 @@ function toRows(loop: LoopRecord): InspectRow[] {
     { 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: "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: "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 },

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

@@ -1,11 +1,6 @@
 import { Command } from "commander";
 import { connectToDaemon, getDaemonHost } from "../../utils/client.js";
-import type {
-  CommandOptions,
-  CommandError,
-  OutputSchema,
-  ListResult,
-} from "../../output/index.js";
+import type { CommandOptions, CommandError, OutputSchema, ListResult } from "../../output/index.js";
 import type { LoopDaemonClient, LoopListItem } from "./types.js";
 
 interface LoopListRow {

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

@@ -1,7 +1,11 @@
 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";
+import {
+  connectScheduleClient,
+  toScheduleCommandError,
+  type ScheduleCommandOptions,
+} from "./shared.js";
 
 interface ScheduleDeleteRow {
   id: string;

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

@@ -25,15 +25,12 @@ export function createScheduleCommand(): Command {
       .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("ls").description("List schedules")).action(
+    withOutput(runLsCommand),
+  );
 
   addJsonAndDaemonHostOptions(
-    schedule
-      .command("inspect")
-      .description("Inspect a schedule")
-      .argument("<id>", "Schedule ID"),
+    schedule.command("inspect").description("Inspect a schedule").argument("<id>", "Schedule ID"),
   ).action(withOutput(runInspectCommand));
 
   addJsonAndDaemonHostOptions(
@@ -44,10 +41,7 @@ export function createScheduleCommand(): Command {
   ).action(withOutput(runLogsCommand));
 
   addJsonAndDaemonHostOptions(
-    schedule
-      .command("pause")
-      .description("Pause a schedule")
-      .argument("<id>", "Schedule ID"),
+    schedule.command("pause").description("Pause a schedule").argument("<id>", "Schedule ID"),
   ).action(withOutput(runPauseCommand));
 
   addJsonAndDaemonHostOptions(
@@ -58,10 +52,7 @@ export function createScheduleCommand(): Command {
   ).action(withOutput(runResumeCommand));
 
   addJsonAndDaemonHostOptions(
-    schedule
-      .command("delete")
-      .description("Delete a schedule")
-      .argument("<id>", "Schedule ID"),
+    schedule.command("delete").description("Delete a schedule").argument("<id>", "Schedule ID"),
   ).action(withOutput(runDeleteCommand));
 
   return schedule;

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

@@ -5,7 +5,11 @@ import {
   createScheduleInspectSchema,
   type ScheduleInspectRow,
 } from "./schema.js";
-import { connectScheduleClient, toScheduleCommandError, type ScheduleCommandOptions } from "./shared.js";
+import {
+  connectScheduleClient,
+  toScheduleCommandError,
+  type ScheduleCommandOptions,
+} from "./shared.js";
 
 export async function runInspectCommand(
   id: string,

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

@@ -1,7 +1,11 @@
 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";
+import {
+  connectScheduleClient,
+  toScheduleCommandError,
+  type ScheduleCommandOptions,
+} from "./shared.js";
 
 export async function runLogsCommand(
   id: string,

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

@@ -19,7 +19,9 @@ export interface ScheduleInspectRow {
   value: string;
 }
 
-export function createScheduleInspectSchema(record: ScheduleRecord): OutputSchema<ScheduleInspectRow> {
+export function createScheduleInspectSchema(
+  record: ScheduleRecord,
+): OutputSchema<ScheduleInspectRow> {
   return {
     idField: "key",
     columns: [

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

@@ -33,11 +33,7 @@ export async function connectScheduleClient(
   }
 }
 
-export function toScheduleCommandError(
-  code: string,
-  action: string,
-  error: unknown,
-): CommandError {
+export function toScheduleCommandError(code: string, action: string, error: unknown): CommandError {
   if (error && typeof error === "object" && "code" in error) {
     return error as CommandError;
   }

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

@@ -20,7 +20,8 @@ export async function runLsCommand(
   const cwd = options.all ? undefined : (options.cwd ?? process.cwd());
 
   try {
-    const payload = cwd === undefined ? await client.listTerminals() : await client.listTerminals(cwd);
+    const payload =
+      cwd === undefined ? await client.listTerminals() : await client.listTerminals(cwd);
     return {
       type: "list",
       data: payload.terminals.map((terminal) => toTerminalRow(terminal, payload.cwd ?? cwd)),

packages/cli/src/utils/client.ts

@@ -10,7 +10,7 @@ export interface ConnectOptions {
 }
 
 const DEFAULT_HOST = "localhost:6767";
-const DEFAULT_TIMEOUT = 5000;
+const DEFAULT_TIMEOUT = 15000;
 const PID_FILENAME = "paseo.pid";
 
 type DaemonTarget =
@@ -207,6 +207,7 @@ export async function connectToDaemon(options?: ConnectOptions): Promise<DaemonC
       url: target.url,
       clientId,
       clientType: "cli",
+      connectTimeoutMs: timeout,
       webSocketFactory: (url: string, config?: { headers?: Record<string, string> }) =>
         nodeWebSocketFactory(url, {
           headers: config?.headers,
@@ -216,23 +217,11 @@ export async function connectToDaemon(options?: ConnectOptions): Promise<DaemonC
     } as unknown as ConstructorParameters<typeof DaemonClient>[0]);
 
     const connectPromise = client.connect();
-    let timeoutHandle: ReturnType<typeof setTimeout> | null = null;
-    const timeoutPromise = new Promise<never>((_, reject) => {
-      timeoutHandle = setTimeout(() => {
-        reject(new Error(`Connection timeout after ${timeout}ms`));
-      }, timeout);
-    });
 
     try {
-      await Promise.race([connectPromise, timeoutPromise]);
-      if (timeoutHandle) {
-        clearTimeout(timeoutHandle);
-      }
+      await connectPromise;
       return client;
     } catch (err) {
-      if (timeoutHandle) {
-        clearTimeout(timeoutHandle);
-      }
       lastError = err;
       await client.close().catch(() => {});
     }

packages/cli/src/utils/paths.ts

@@ -21,7 +21,6 @@ export function isSameOrDescendantPath(basePath: string, candidatePath: string):
   }
 
   return (
-    normalizedCandidate === normalizedBase ||
-    normalizedCandidate.startsWith(normalizedBase + "/")
+    normalizedCandidate === normalizedBase || normalizedCandidate.startsWith(normalizedBase + "/")
   );
 }