Merge remote-tracking branch 'origin/main' into merge/main-into-dev

# Conflicts:
#	packages/app/src/app/h/[serverId]/index.tsx
#	packages/app/src/components/agent-stream-view.tsx
#	packages/app/src/utils/host-routes.ts

packages/app/src/utils/host-routes.ts

@@ -288,125 +288,125 @@ export function parseHostWorkspaceRouteFromPathname(
   return { serverId, workspaceId };
 }
 
-export function buildHostWorkspaceRoute(serverId: string, workspaceId: string): string {
+export function buildHostWorkspaceRoute(serverId: string, workspaceId: string) {
   const normalizedServerId = trimNonEmpty(serverId);
   const normalizedWorkspaceId = trimNonEmpty(workspaceId);
   if (!normalizedServerId || !normalizedWorkspaceId) {
-    return "/";
+    return "/" as const;
   }
   const encodedWorkspaceId = encodeWorkspaceIdForPathSegment(normalizedWorkspaceId);
   if (!encodedWorkspaceId) {
-    return "/";
+    return "/" as const;
   }
-  return `/h/${encodeSegment(normalizedServerId)}/workspace/${encodeSegment(encodedWorkspaceId)}`;
+  return `/h/${encodeSegment(normalizedServerId)}/workspace/${encodeSegment(encodedWorkspaceId)}` as const;
 }
 
 export function buildHostWorkspaceOpenRoute(
   serverId: string,
   workspaceId: string,
   openIntent: string,
-): string {
+) {
   const base = buildHostWorkspaceRoute(serverId, workspaceId);
   const normalizedOpenIntent = trimNonEmpty(openIntent);
   if (base === "/" || !normalizedOpenIntent) {
     return base;
   }
-  return `${base}?open=${encodeURIComponent(normalizedOpenIntent)}`;
+  return `${base}?open=${encodeURIComponent(normalizedOpenIntent)}` as const;
 }
 
 export function buildHostAgentDetailRoute(
   serverId: string,
   agentId: string,
   workspaceId?: string,
-): string {
+) {
   const normalizedWorkspaceId = trimNonEmpty(workspaceId);
   if (normalizedWorkspaceId) {
     const normalizedAgentId = trimNonEmpty(agentId);
     if (!normalizedAgentId) {
-      return "/";
+      return "/" as const;
     }
     return buildHostWorkspaceOpenRoute(serverId, normalizedWorkspaceId, `agent:${normalizedAgentId}`);
   }
   const normalizedServerId = trimNonEmpty(serverId);
   const normalizedAgentId = trimNonEmpty(agentId);
   if (!normalizedServerId || !normalizedAgentId) {
-    return "/";
+    return "/" as const;
   }
-  return `${buildHostRootRoute(normalizedServerId)}/agent/${encodeSegment(normalizedAgentId)}`;
+  return `${buildHostRootRoute(normalizedServerId)}/agent/${encodeSegment(normalizedAgentId)}` as const;
 }
 
-export function buildHostRootRoute(serverId: string): string {
+export function buildHostRootRoute(serverId: string) {
   const normalized = trimNonEmpty(serverId);
   if (!normalized) {
-    return "/";
+    return "/" as const;
   }
-  return `/h/${encodeSegment(normalized)}`;
+  return `/h/${encodeSegment(normalized)}` as const;
 }
 
-export function buildHostSessionsRoute(serverId: string): string {
+export function buildHostSessionsRoute(serverId: string) {
   const base = buildHostRootRoute(serverId);
   if (base === "/") {
-    return "/";
+    return "/" as const;
   }
-  return `${base}/sessions`;
+  return `${base}/sessions` as const;
 }
 
-export function buildHostOpenProjectRoute(serverId: string): string {
+export function buildHostOpenProjectRoute(serverId: string) {
   const base = buildHostRootRoute(serverId);
   if (base === "/") {
-    return "/";
+    return "/" as const;
   }
-  return `${base}/open-project`;
+  return `${base}/open-project` as const;
 }
 
 export function buildHostNewWorkspaceRoute(
   serverId: string,
   sourceDirectory: string,
   options?: { displayName?: string },
-): string {
+){
   const base = buildHostRootRoute(serverId);
   if (base === "/") {
-    return "/";
+    return "/" as const;
   }
   const params = new URLSearchParams();
   params.set("dir", sourceDirectory);
   if (options?.displayName) {
     params.set("name", options.displayName);
   }
-  return `${base}/new?${params.toString()}`;
+  return `${base}/new?${params.toString()}` as const;
 }
 
-export function buildHostSettingsRoute(serverId: string): string {
+export function buildHostSettingsRoute(serverId: string) {
   const base = buildHostRootRoute(serverId);
   if (base === "/") {
-    return "/";
+    return "/" as const;
   }
-  return `${base}/settings`;
+  return `${base}/settings` as const;
 }
 
-export function mapPathnameToServer(pathname: string, nextServerId: string): string {
+export function mapPathnameToServer(pathname: string, nextServerId: string) {
   const normalized = trimNonEmpty(nextServerId);
   if (!normalized) {
-    return "/";
+    return "/" as const;
   }
 
   const suffix = pathname.replace(/^\/h\/[^/]+\/?/, "");
   const base = buildHostRootRoute(normalized);
   if (suffix.startsWith("settings")) {
-    return `${base}/settings`;
+    return `${base}/settings` as const;
   }
   if (suffix.startsWith("sessions")) {
-    return `${base}/sessions`;
+    return `${base}/sessions` as const;
   }
   if (suffix.startsWith("open-project")) {
-    return `${base}/open-project`;
+    return `${base}/open-project` as const;
   }
   const workspaceRoute = parseHostWorkspaceRouteFromPathname(pathname);
   if (workspaceRoute) {
     return buildHostWorkspaceRoute(normalized, workspaceRoute.workspaceId);
   }
   if (suffix.startsWith("agent/")) {
-    return `${base}/${suffix}`;
+    return `${base}/${suffix}` as const;
   }
   return base;
 }

packages/app/src/utils/new-agent-routing.ts

@@ -69,7 +69,7 @@ export function resolveNewAgentWorkingDir(
   return inferMainRepoRootFromPaseoWorktreePath(cwd) ?? cwd;
 }
 
-export function buildNewAgentRoute(serverId: string, workingDir?: string | null): string {
+export function buildNewAgentRoute(serverId: string, workingDir?: string | null) {
   const trimmedWorkingDir = workingDir?.trim();
   return buildHostWorkspaceRoute(serverId, trimmedWorkingDir || ".");
 }

packages/app/src/utils/notification-routing.ts

@@ -27,17 +27,17 @@ export function resolveNotificationTarget(data: NotificationData): {
   };
 }
 
-export function buildNotificationRoute(data: NotificationData): string {
+export function buildNotificationRoute(data: NotificationData) {
   const { serverId, agentId, workspaceId } = resolveNotificationTarget(data);
   if (serverId && agentId) {
     if (workspaceId) {
       const base = buildHostWorkspaceRoute(serverId, workspaceId);
-      return `${base}?open=${encodeURIComponent(`agent:${agentId}`)}`;
+      return `${base}?open=${encodeURIComponent(`agent:${agentId}`)}` as const;
     }
     return buildHostAgentDetailRoute(serverId, agentId);
   }
   if (serverId) {
     return buildHostRootRoute(serverId);
   }
-  return "/";
+  return "/" as const;
 }

packages/app/src/utils/workspace-archive-navigation.ts

@@ -41,7 +41,7 @@ export function buildWorkspaceArchiveRedirectRoute(input: {
   serverId: string;
   archivedWorkspaceId: string;
   workspaces: Iterable<WorkspaceDescriptor>;
-}): string {
+}) {
   const redirectWorkspaceId = resolveWorkspaceArchiveRedirectWorkspaceId({
     archivedWorkspaceId: input.archivedWorkspaceId,
     workspaces: input.workspaces,

packages/app/src/utils/workspace-navigation.ts

@@ -25,7 +25,7 @@ function getPreparedTarget(target: WorkspaceTabTarget): WorkspaceTabTarget {
   return { kind: "draft", draftId: generateDraftId() };
 }
 
-export function prepareWorkspaceTab(input: PrepareWorkspaceTabInput): string {
+export function prepareWorkspaceTab(input: PrepareWorkspaceTabInput) {
   const target = getPreparedTarget(input.target);
   const key =
     buildWorkspaceTabPersistenceKey({