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/server/src/client/daemon-client-transport.test.ts

@@ -1,3 +1,4 @@
+import { EventEmitter } from "node:events";
 import { describe, expect, test, vi } from "vitest";
 import {
   createEncryptedTransport,
@@ -114,6 +115,22 @@ describe("daemon-client transport helpers", () => {
     expect(ws.removeEventListener).toHaveBeenCalledWith("message", expect.any(Function));
   });
 
+  test("createWebSocketTransportFactory suppresses close-before-open ws errors", () => {
+    class MockNodeWebSocket extends EventEmitter {
+      readyState = 0;
+      send = vi.fn();
+      close = vi.fn((code?: number, reason?: string) => {
+        this.emit("error", new Error("WebSocket was closed before the connection was established"));
+        this.emit("close", { code, reason });
+      });
+    }
+
+    const ws = new MockNodeWebSocket();
+    const transport = createWebSocketTransportFactory(() => ws)({ url: "ws://example.test" });
+
+    expect(() => transport.close(1001, "Connection timed out")).not.toThrow();
+  });
+
   test("describeTransportClose prefers reason, then message, then code", () => {
     expect(describeTransportClose({ reason: "peer closed" })).toBe("peer closed");
     expect(describeTransportClose({ message: "closed" })).toBe("closed");

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

@@ -32,7 +32,19 @@ export function createWebSocketTransportFactory(factory: WebSocketFactory): Daem
         }
         ws.send(data);
       },
-      close: (code?: number, reason?: string) => ws.close(code, reason),
+      close: (code?: number, reason?: string) => {
+        // Node's `ws` may emit an `error` when a connecting socket is closed before the
+        // handshake completes. Keep a temporary no-op handler attached so cleanup during
+        // connect timeouts does not crash the CLI with an unhandled error event.
+        const suppressEarlyCloseError = bindTemporaryEarlyCloseErrorHandler(ws);
+        try {
+          ws.close(code, reason);
+        } finally {
+          if (typeof ws.on !== "function" && typeof ws.addEventListener !== "function") {
+            suppressEarlyCloseError();
+          }
+        }
+      },
       onOpen: (handler) => bindWsHandler(ws, "open", handler),
       onClose: (handler) => bindWsHandler(ws, "close", handler),
       onError: (handler) => bindWsHandler(ws, "error", handler),
@@ -41,6 +53,52 @@ export function createWebSocketTransportFactory(factory: WebSocketFactory): Daem
   };
 }
 
+function bindTemporaryEarlyCloseErrorHandler(ws: WebSocketLike): () => void {
+  const noop = () => {};
+
+  if (typeof ws.addEventListener === "function") {
+    ws.addEventListener("error", noop);
+    const removeOnClose = bindWsHandler(ws, "close", () => {
+      removeOnClose();
+      if (typeof ws.removeEventListener === "function") {
+        ws.removeEventListener("error", noop);
+      }
+    });
+    return () => {
+      removeOnClose();
+      if (typeof ws.removeEventListener === "function") {
+        ws.removeEventListener("error", noop);
+      }
+    };
+  }
+
+  if (typeof ws.on === "function") {
+    ws.on("error", noop);
+    const removeOnClose = bindWsHandler(ws, "close", () => {
+      removeOnClose();
+      if (typeof ws.off === "function") {
+        ws.off("error", noop);
+        return;
+      }
+      if (typeof ws.removeListener === "function") {
+        ws.removeListener("error", noop);
+      }
+    });
+    return () => {
+      removeOnClose();
+      if (typeof ws.off === "function") {
+        ws.off("error", noop);
+        return;
+      }
+      if (typeof ws.removeListener === "function") {
+        ws.removeListener("error", noop);
+      }
+    };
+  }
+
+  return () => {};
+}
+
 export function bindWsHandler(
   ws: WebSocketLike,
   event: "open" | "close" | "error" | "message",

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

@@ -759,7 +759,7 @@ describe("DaemonClient", () => {
     expect(request.message.type).toBe("subscribe_checkout_diff_request");
     expect(request.message.subscriptionId).toBe("checkout-sub-1");
     expect(request.message.cwd).toBe("/tmp/project");
-    expect(request.message.compare).toEqual({ mode: "uncommitted" });
+    expect(request.message.compare).toEqual({ mode: "uncommitted", ignoreWhitespace: false });
 
     mock.triggerMessage(
       JSON.stringify({
@@ -818,7 +818,11 @@ describe("DaemonClient", () => {
     };
     expect(subscribeRequest.message.type).toBe("subscribe_checkout_diff_request");
     expect(subscribeRequest.message.cwd).toBe("/tmp/project");
-    expect(subscribeRequest.message.compare).toEqual({ mode: "base", baseRef: "main" });
+    expect(subscribeRequest.message.compare).toEqual({
+      mode: "base",
+      baseRef: "main",
+      ignoreWhitespace: false,
+    });
 
     mock.triggerMessage(
       JSON.stringify({

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

@@ -74,7 +74,7 @@ import type {
   AgentProvider,
   AgentSessionConfig,
 } from "../server/agent/agent-sdk-types.js";
-import { getAgentProviderDefinition } from "../server/agent/provider-manifest.js";
+import type { MutableDaemonConfig, MutableDaemonConfigPatch } from "../shared/messages.js";
 import { isRelayClientWebSocketUrl } from "../shared/daemon-endpoints.js";
 import {
   asUint8Array,
@@ -285,10 +285,7 @@ type ChatCreatePayload = Extract<
   SessionOutboundMessage,
   { type: "chat/create/response" }
 >["payload"];
-type ChatListPayload = Extract<
-  SessionOutboundMessage,
-  { type: "chat/list/response" }
->["payload"];
+type ChatListPayload = Extract<SessionOutboundMessage, { type: "chat/list/response" }>["payload"];
 type ChatInspectPayload = Extract<
   SessionOutboundMessage,
   { type: "chat/inspect/response" }
@@ -297,38 +294,17 @@ 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 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 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" }
@@ -529,10 +505,18 @@ type WaitHandle<T> = {
 };
 
 type RpcWaitResult<T> = { kind: "ok"; value: T } | { kind: "error"; error: DaemonRpcError };
-type CorrelatedResponseMessage = Extract<
+type GetDaemonConfigResponse = Extract<
   SessionOutboundMessage,
-  { payload: { requestId: string } }
+  { type: "get_daemon_config_response" }
 >;
+type SetDaemonConfigResponse = Extract<
+  SessionOutboundMessage,
+  { type: "set_daemon_config_response" }
+>;
+type CorrelatedResponseMessage =
+  | Extract<SessionOutboundMessage, { payload: { requestId: string } }>
+  | GetDaemonConfigResponse
+  | SetDaemonConfigResponse;
 type CorrelatedResponseType = CorrelatedResponseMessage["type"];
 type CorrelatedResponsePayload<TType extends CorrelatedResponseType> = Extract<
   CorrelatedResponseMessage,
@@ -2484,11 +2468,7 @@ export class DaemonClient {
     });
   }
 
-  async stashPop(
-    cwd: string,
-    stashIndex: number,
-    requestId?: string,
-  ): Promise<StashPopPayload> {
+  async stashPop(cwd: string, stashIndex: number, requestId?: string): Promise<StashPopPayload> {
     return this.sendCorrelatedSessionRequest({
       requestId,
       message: {
@@ -2784,6 +2764,34 @@ export class DaemonClient {
     });
   }
 
+  async getDaemonConfig(
+    requestId?: string,
+  ): Promise<{ requestId: string; config: MutableDaemonConfig }> {
+    return this.sendCorrelatedSessionRequest({
+      requestId,
+      message: {
+        type: "get_daemon_config_request",
+      },
+      responseType: "get_daemon_config_response",
+      timeout: 10000,
+    });
+  }
+
+  async patchDaemonConfig(
+    config: MutableDaemonConfigPatch,
+    requestId?: string,
+  ): Promise<{ requestId: string; config: MutableDaemonConfig }> {
+    return this.sendCorrelatedSessionRequest({
+      requestId,
+      message: {
+        type: "set_daemon_config_request",
+        config,
+      },
+      responseType: "set_daemon_config_response",
+      timeout: 10000,
+    });
+  }
+
   async refreshProvidersSnapshot(options?: {
     cwd?: string;
     requestId?: string;
@@ -3433,8 +3441,7 @@ export class DaemonClient {
   }
 
   async loopLogs(options: string | LoopLogsOptions, afterSeq?: number): Promise<LoopLogsPayload> {
-    const normalized =
-      typeof options === "string" ? { id: options, afterSeq } : options;
+    const normalized = typeof options === "string" ? { id: options, afterSeq } : options;
     return this.sendCorrelatedSessionRequest({
       requestId: normalized.requestId,
       message: {
@@ -4018,10 +4025,6 @@ function resolveAgentConfig(options: CreateAgentRequestOptions): AgentSessionCon
     throw new Error("createAgent requires provider and cwd");
   }
 
-  if (!merged.modeId) {
-    merged.modeId = getAgentProviderDefinition(merged.provider).defaultModeId ?? undefined;
-  }
-
   return {
     ...merged,
     provider: merged.provider,